@v-ibe/core 0.1.0

package/dist/DI/scoped-container.js

@@ -0,0 +1,193 @@
+import { hasLifecycle } from "./lifecycle.js";
+class ScopedContainer {
+  #local = /* @__PURE__ */ new Map();
+  #registered = /* @__PURE__ */ new Set();
+  #parent;
+  // Dependency graph for topological sort
+  #dependencies = /* @__PURE__ */ new Map();
+  #dependents = /* @__PURE__ */ new Map();
+  #ready = false;
+  constructor(parent) {
+    this.#parent = parent;
+  }
+  /**
+   * Register a service constructor in this scope
+   */
+  register(token) {
+    this.#registered.add(token);
+    if (!this.#dependencies.has(token)) {
+      this.#dependencies.set(token, /* @__PURE__ */ new Set());
+    }
+    if (!this.#dependents.has(token)) {
+      this.#dependents.set(token, /* @__PURE__ */ new Set());
+    }
+  }
+  /**
+   * Register a dependency relationship between services in this scope.
+   * Only for dependencies that are BOTH registered locally.
+   * Cross-scope dependencies are resolved via parent chain at get() time.
+   */
+  registerDependency(parent, dependency) {
+    if (!this.#registered.has(parent)) {
+      throw new Error(
+        `Cannot register dependency: ${parent.name} is not registered in this scope.`
+      );
+    }
+    if (!this.#registered.has(dependency)) {
+      throw new Error(
+        `Cannot register dependency: ${dependency.name} is not registered in this scope.`
+      );
+    }
+    if (!this.#dependencies.has(parent)) {
+      this.#dependencies.set(parent, /* @__PURE__ */ new Set());
+    }
+    this.#dependencies.get(parent).add(dependency);
+    if (!this.#dependents.has(dependency)) {
+      this.#dependents.set(dependency, /* @__PURE__ */ new Set());
+    }
+    this.#dependents.get(dependency).add(parent);
+  }
+  /**
+   * Get bootstrap order using topological sort (Kahn's algorithm).
+   * Only considers locally registered services.
+   */
+  *#getBootstrapOrder() {
+    const inDegree = /* @__PURE__ */ new Map();
+    const queue = [];
+    for (const service of this.#registered) {
+      const deps = this.#dependencies.get(service) || /* @__PURE__ */ new Set();
+      inDegree.set(service, deps.size);
+      if (deps.size === 0) {
+        queue.push(service);
+      }
+    }
+    while (queue.length > 0) {
+      const service = queue.shift();
+      yield service;
+      const dependents = this.#dependents.get(service) || /* @__PURE__ */ new Set();
+      for (const dependent of dependents) {
+        const newInDegree = inDegree.get(dependent) - 1;
+        inDegree.set(dependent, newInDegree);
+        if (newInDegree === 0) {
+          queue.push(dependent);
+        }
+      }
+    }
+    const remaining = Array.from(inDegree.entries()).filter(
+      ([_, degree]) => degree > 0
+    );
+    if (remaining.length > 0) {
+      const cycleServices = remaining.map(([service]) => service.name).join(", ");
+      throw new Error(
+        `Circular dependency detected in scope. Services with unresolved dependencies: ${cycleServices}`
+      );
+    }
+  }
+  /**
+   * Bootstrap all locally registered services in dependency order.
+   * Each instance is associated with this container via __container.
+   *
+   * Services with async onBootstrap() are launched as fire-and-forget.
+   * Use the reactive pattern (@Store with isLoading) to handle async state.
+   */
+  bootstrapSync() {
+    if (this.#ready) return;
+    for (const ctor of this.#getBootstrapOrder()) {
+      const inst = new ctor();
+      inst.__container = this;
+      this.#local.set(ctor, inst);
+      if (hasLifecycle(inst)) {
+        inst.onBootstrap().catch((err) => {
+          console.error(`[ScopedContainer] Error in onBootstrap for ${ctor.name}:`, err);
+        });
+      }
+    }
+    this.#ready = true;
+  }
+  /**
+   * Bootstrap all locally registered services, awaiting async onBootstrap hooks.
+   * Use this in the DOM init() path where async is available.
+   */
+  async bootstrap() {
+    if (this.#ready) return;
+    for (const ctor of this.#getBootstrapOrder()) {
+      const inst = new ctor();
+      inst.__container = this;
+      this.#local.set(ctor, inst);
+      if (hasLifecycle(inst)) {
+        await inst.onBootstrap();
+      }
+    }
+    this.#ready = true;
+  }
+  /**
+   * Resolve a service by walking up the parent chain.
+   * Checks local scope first, then parent, then grandparent, etc.
+   */
+  get(ctor) {
+    if (this.#local.has(ctor)) {
+      return this.#local.get(ctor);
+    }
+    if (this.#parent) {
+      return this.#parent.get(ctor);
+    }
+    throw new Error(
+      `Service ${ctor.name} not found in any scope. Make sure a parent component provides it via services: [${ctor.name}].`
+    );
+  }
+  /**
+   * Check if a service exists in this scope or any parent scope.
+   */
+  has(ctor) {
+    if (this.#local.has(ctor)) return true;
+    if (this.#parent) return this.#parent.has(ctor);
+    return false;
+  }
+  /**
+   * Check if a service is registered locally (not including parents).
+   */
+  hasLocal(ctor) {
+    return this.#local.has(ctor);
+  }
+  /**
+   * Check if bootstrap has been called.
+   */
+  get isReady() {
+    return this.#ready;
+  }
+  /**
+   * Get the parent container.
+   */
+  get parent() {
+    return this.#parent;
+  }
+  /**
+   * Get all locally instantiated service instances.
+   */
+  getAllInstances() {
+    return Array.from(this.#local.values());
+  }
+  /**
+   * Dispose all local services and reset container.
+   * Calls onDestroy() on services that implement it.
+   */
+  dispose() {
+    for (const instance of this.#local.values()) {
+      if (typeof instance.onDestroy === "function") {
+        try {
+          instance.onDestroy();
+        } catch (error) {
+          console.error("[ScopedContainer] Error in onDestroy:", error);
+        }
+      }
+    }
+    this.#local.clear();
+    this.#registered.clear();
+    this.#dependencies.clear();
+    this.#dependents.clear();
+    this.#ready = false;
+  }
+}
+export {
+  ScopedContainer
+};

package/dist/DI/service-metadata.d.ts

@@ -0,0 +1,32 @@
+import { Constructor } from './types';
+/**
+ * Metadata for a service registered via decorators
+ * This is stored globally and can be used to register services in any container
+ */
+export interface ServiceMetadata {
+    constructor: Constructor;
+    dependencies: Set<Constructor>;
+}
+/**
+ * Options for registering service metadata
+ */
+export interface ServiceMetadataOptions {
+    dependencies?: Set<Constructor>;
+}
+/**
+ * Register service metadata (called by decorators)
+ */
+export declare function registerServiceMetadata(ctor: Constructor, options: ServiceMetadataOptions): void;
+/**
+ * Get metadata for a service
+ */
+export declare function getServiceMetadata(ctor: Constructor): ServiceMetadata | undefined;
+/**
+ * Get all registered service metadata
+ * Useful for registering all services in a container
+ */
+export declare function getAllServiceMetadata(): Map<Constructor, ServiceMetadata>;
+/**
+ * Clear all metadata (useful for testing)
+ */
+export declare function clearServiceMetadata(): void;

package/dist/DI/service-metadata.js

@@ -0,0 +1,31 @@
+const serviceMetadataRegistry = /* @__PURE__ */ new Map();
+function registerServiceMetadata(ctor, options) {
+  const existing = serviceMetadataRegistry.get(ctor);
+  if (existing) {
+    if (options.dependencies) {
+      for (const dep of options.dependencies) {
+        existing.dependencies.add(dep);
+      }
+    }
+  } else {
+    serviceMetadataRegistry.set(ctor, {
+      constructor: ctor,
+      dependencies: options.dependencies || /* @__PURE__ */ new Set()
+    });
+  }
+}
+function getServiceMetadata(ctor) {
+  return serviceMetadataRegistry.get(ctor);
+}
+function getAllServiceMetadata() {
+  return new Map(serviceMetadataRegistry);
+}
+function clearServiceMetadata() {
+  serviceMetadataRegistry.clear();
+}
+export {
+  clearServiceMetadata,
+  getAllServiceMetadata,
+  getServiceMetadata,
+  registerServiceMetadata
+};

package/dist/DI/types.d.ts

@@ -0,0 +1,4 @@
+export type Constructor<T = {}> = new (...args: any[]) => T;
+export interface OnBootstrap {
+    onBootstrap(): Promise<void>;
+}

package/dist/behaviors/__tests__/behavior-system.test.d.ts

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

package/dist/behaviors/behavior-manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * BehaviorManager manages the lifecycle of Behavior instances attached to elements.
+ *
+ * Each component has its own BehaviorManager instance to track and manage
+ * behaviors attached to native elements within that component.
+ *
+ * Lifecycle:
+ * 1. attachBehaviors() - Called from bindProps, resolves and attaches behaviors
+ * 2. onInit() - Called on each behavior after props are assigned
+ * 3. onDestroy() - Called when disconnectAll() or disconnectElement() is called
+ */
+export declare class BehaviorManager {
+    private instances;
+    private hostComponent;
+    constructor(hostComponent?: any);
+    /**
+     * Main entry point. Analyzes all props for an element,
+     * instantiates corresponding behaviors, and returns which props were consumed.
+     *
+     * @param el - The element to attach behaviors to
+     * @param props - All props from JSX
+     * @returns Set<string> with names of all props that were handled by behaviors
+     */
+    attachBehaviors(el: Element, props: Record<string, any>): Set<string>;
+    /**
+     * Attaches a specific behavior to an element.
+     */
+    private attach;
+    /**
+     * Gets the names of all @Prop decorated fields in a behavior class.
+     */
+    private getBehaviorPropNames;
+    /**
+     * Gets a specific behavior instance from an element.
+     * Useful for debugging or programmatic interaction.
+     */
+    get<T>(el: Element, behaviorName: string): T | undefined;
+    /**
+     * Gets all behaviors attached to an element.
+     */
+    getAll(el: Element): Map<string, any> | undefined;
+    /**
+     * Disconnects all behaviors from all elements.
+     * Called from disconnectedCallback of the parent component.
+     */
+    disconnectAll(): void;
+    /**
+     * Disconnects behaviors from a specific element.
+     * Useful if an element is removed from DOM but the component is still alive.
+     */
+    disconnectElement(el: Element): void;
+    /**
+     * Gets the total number of elements that have behaviors attached.
+     */
+    get elementCount(): number;
+    /**
+     * Gets the total number of behavior instances managed.
+     */
+    get behaviorCount(): number;
+}

package/dist/behaviors/behavior-manager.js

@@ -0,0 +1,131 @@
+import { BehaviorRegistry } from "./behavior-registry.js";
+import { HOST_KEY, COMPONENT_HOST_KEY, BEHAVIOR_PROPS } from "./constants.js";
+class BehaviorManager {
+  constructor(hostComponent) {
+    this.instances = /* @__PURE__ */ new Map();
+    this.hostComponent = hostComponent;
+  }
+  /**
+   * Main entry point. Analyzes all props for an element,
+   * instantiates corresponding behaviors, and returns which props were consumed.
+   * 
+   * @param el - The element to attach behaviors to
+   * @param props - All props from JSX
+   * @returns Set<string> with names of all props that were handled by behaviors
+   */
+  attachBehaviors(el, props) {
+    const behaviorMap = BehaviorRegistry.resolve(props);
+    const consumedProps = /* @__PURE__ */ new Set();
+    for (const [BehaviorClass, config] of behaviorMap) {
+      const behaviorName = BehaviorClass.name;
+      this.attach(el, BehaviorClass, behaviorName, config);
+      const behaviorProps = this.getBehaviorPropNames(BehaviorClass);
+      behaviorProps.forEach((prop) => {
+        if (prop in props) {
+          consumedProps.add(prop);
+        }
+      });
+    }
+    return consumedProps;
+  }
+  /**
+   * Attaches a specific behavior to an element.
+   */
+  attach(el, BehaviorClass, behaviorName, config) {
+    const instance = new BehaviorClass();
+    const hostPropName = BehaviorClass[HOST_KEY];
+    if (hostPropName) {
+      instance[hostPropName] = el;
+    }
+    const componentHostPropName = BehaviorClass[COMPONENT_HOST_KEY];
+    if (componentHostPropName && this.hostComponent) {
+      instance[componentHostPropName] = this.hostComponent;
+    }
+    if (this.hostComponent?.__container) {
+      instance.__container = this.hostComponent.__container;
+    }
+    Object.assign(instance, config);
+    if (!this.instances.has(el)) {
+      this.instances.set(el, /* @__PURE__ */ new Map());
+    }
+    this.instances.get(el).set(behaviorName, instance);
+    if (typeof instance.onInit === "function") {
+      instance.onInit();
+    }
+  }
+  /**
+   * Gets the names of all @Prop decorated fields in a behavior class.
+   */
+  getBehaviorPropNames(BehaviorClass) {
+    const props = BehaviorClass[BEHAVIOR_PROPS];
+    return props ? new Set(props) : /* @__PURE__ */ new Set();
+  }
+  /**
+   * Gets a specific behavior instance from an element.
+   * Useful for debugging or programmatic interaction.
+   */
+  get(el, behaviorName) {
+    return this.instances.get(el)?.get(behaviorName);
+  }
+  /**
+   * Gets all behaviors attached to an element.
+   */
+  getAll(el) {
+    return this.instances.get(el);
+  }
+  /**
+   * Disconnects all behaviors from all elements.
+   * Called from disconnectedCallback of the parent component.
+   */
+  disconnectAll() {
+    for (const [el, behaviors] of this.instances) {
+      for (const [name, instance] of behaviors) {
+        if (typeof instance.onDestroy === "function") {
+          try {
+            instance.onDestroy();
+          } catch (e) {
+            console.error(`[Behavior ${name}] Error in onDestroy:`, e);
+          }
+        }
+      }
+    }
+    this.instances.clear();
+  }
+  /**
+   * Disconnects behaviors from a specific element.
+   * Useful if an element is removed from DOM but the component is still alive.
+   */
+  disconnectElement(el) {
+    const behaviors = this.instances.get(el);
+    if (!behaviors) return;
+    for (const [name, instance] of behaviors) {
+      if (typeof instance.onDestroy === "function") {
+        try {
+          instance.onDestroy();
+        } catch (e) {
+          console.error(`[Behavior ${name}] Error in onDestroy:`, e);
+        }
+      }
+    }
+    this.instances.delete(el);
+  }
+  /**
+   * Gets the total number of elements that have behaviors attached.
+   */
+  get elementCount() {
+    return this.instances.size;
+  }
+  /**
+   * Gets the total number of behavior instances managed.
+   */
+  get behaviorCount() {
+    let count = 0;
+    for (const [, behaviors] of this.instances) {
+      count += behaviors.size;
+    }
+    return count;
+  }
+}
+export {
+  BehaviorManager
+};

package/dist/behaviors/behavior-registry.d.ts

@@ -0,0 +1,68 @@
+type Constructor = new (...args: any[]) => any;
+/**
+ * BehaviorRegistry manages the mapping between prop names and Behavior classes.
+ *
+ * When a @Behavior class is registered, all its @Prop decorated fields are indexed.
+ * This allows the system to resolve which behaviors to instantiate based on JSX props.
+ *
+ * @example
+ * @Behavior
+ * class Link {
+ *   @Prop() link: boolean = true;      // Activator prop
+ *   @Prop() href: string = '';         // Config prop
+ *   @Prop() activeClass?: string;      // Optional config prop
+ * }
+ *
+ * // In JSX: <a link href="/home" activeClass="active">
+ * // BehaviorRegistry.resolve({link: true, href: '/home', activeClass: 'active'})
+ * // Returns: Map { Link -> {link: true, href: '/home', activeClass: 'active'} }
+ */
+export declare class BehaviorRegistry {
+    private static propIndex;
+    private static allBehaviorProps;
+    /**
+     * Registers a class as a Behavior.
+     * Called from the @Behavior decorator.
+     *
+     * @throws Error if a prop name is already registered by another behavior
+     */
+    static register(cls: Constructor): void;
+    /**
+     * Resolves which behaviors to apply and with what configuration.
+     *
+     * Groups all props by their registered Behavior class.
+     *
+     * @param props - Props from JSX (e.g., {link: true, href: '/', activeClass: 'active'})
+     * @returns Map<BehaviorClass, config>
+     */
+    static resolve(props: Record<string, any>): Map<Constructor, Record<string, any>>;
+    /**
+     * Checks if a prop name belongs to any registered behavior.
+     */
+    static isBehaviorProp(name: string): boolean;
+    /**
+     * Gets the behavior class for a given prop name.
+     */
+    static getBehaviorForProp(propName: string): Constructor | undefined;
+    /**
+     * Gets all prop names registered for a behavior class.
+     */
+    static getPropsForBehavior(cls: Constructor): Set<string>;
+    /**
+     * Unregisters a behavior (useful for testing).
+     */
+    static unregister(cls: Constructor): void;
+    /**
+     * Clears all registered behaviors (useful for testing).
+     */
+    static clear(): void;
+    /**
+     * Gets all registered prop names (useful for debugging).
+     */
+    static getRegisteredProps(): string[];
+    /**
+     * Debug output of all registered behaviors and their props.
+     */
+    static debug(): void;
+}
+export {};

package/dist/behaviors/behavior-registry.js

@@ -0,0 +1,105 @@
+import { BEHAVIOR_PROPS } from "./constants.js";
+const _BehaviorRegistry = class _BehaviorRegistry {
+  /**
+   * Registers a class as a Behavior.
+   * Called from the @Behavior decorator.
+   * 
+   * @throws Error if a prop name is already registered by another behavior
+   */
+  static register(cls) {
+    const props = cls[BEHAVIOR_PROPS];
+    if (!props || props.size === 0) {
+      console.warn(`[Behavior] ${cls.name} registered without @Props. Did you forget to decorate the properties?`);
+    }
+    props?.forEach((propName) => {
+      if (this.propIndex.has(propName)) {
+        const existing = this.propIndex.get(propName).name;
+        throw new Error(
+          `[Behavior Conflict] Property "${propName}" is already registered by behavior "${existing}". Cannot be used in "${cls.name}".`
+        );
+      }
+      this.propIndex.set(propName, cls);
+      this.allBehaviorProps.add(propName);
+    });
+  }
+  /**
+   * Resolves which behaviors to apply and with what configuration.
+   * 
+   * Groups all props by their registered Behavior class.
+   * 
+   * @param props - Props from JSX (e.g., {link: true, href: '/', activeClass: 'active'})
+   * @returns Map<BehaviorClass, config>
+   */
+  static resolve(props) {
+    const behaviors = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(props)) {
+      const BehaviorClass = this.propIndex.get(key);
+      if (BehaviorClass) {
+        if (!behaviors.has(BehaviorClass)) {
+          behaviors.set(BehaviorClass, {});
+        }
+        behaviors.get(BehaviorClass)[key] = value;
+      }
+    }
+    return behaviors;
+  }
+  /**
+   * Checks if a prop name belongs to any registered behavior.
+   */
+  static isBehaviorProp(name) {
+    return this.allBehaviorProps.has(name);
+  }
+  /**
+   * Gets the behavior class for a given prop name.
+   */
+  static getBehaviorForProp(propName) {
+    return this.propIndex.get(propName);
+  }
+  /**
+   * Gets all prop names registered for a behavior class.
+   */
+  static getPropsForBehavior(cls) {
+    const props = cls[BEHAVIOR_PROPS];
+    return props ? new Set(props) : /* @__PURE__ */ new Set();
+  }
+  /**
+   * Unregisters a behavior (useful for testing).
+   */
+  static unregister(cls) {
+    const props = cls[BEHAVIOR_PROPS];
+    props?.forEach((propName) => {
+      if (this.propIndex.get(propName) === cls) {
+        this.propIndex.delete(propName);
+        this.allBehaviorProps.delete(propName);
+      }
+    });
+  }
+  /**
+   * Clears all registered behaviors (useful for testing).
+   */
+  static clear() {
+    this.propIndex.clear();
+    this.allBehaviorProps.clear();
+  }
+  /**
+   * Gets all registered prop names (useful for debugging).
+   */
+  static getRegisteredProps() {
+    return Array.from(this.propIndex.keys());
+  }
+  /**
+   * Debug output of all registered behaviors and their props.
+   */
+  static debug() {
+    console.log(
+      "[BehaviorRegistry] Registered props:",
+      Array.from(this.propIndex.entries()).map(([k, v]) => `${k} -> ${v.name}`)
+    );
+  }
+};
+_BehaviorRegistry.propIndex = /* @__PURE__ */ new Map();
+_BehaviorRegistry.allBehaviorProps = /* @__PURE__ */ new Set();
+let BehaviorRegistry = _BehaviorRegistry;
+export {
+  BehaviorRegistry
+};

package/dist/behaviors/constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Symbol para almacenar metadata de props en las clases Behavior.
+ * Usado por @Prop para registrar qué campos son props del behavior.
+ */
+export declare const BEHAVIOR_PROPS: unique symbol;
+/**
+ * Symbol para marcar qué campo recibe el elemento host.
+ * Usado por @Host para inyectar el elemento al que se adjunta el behavior.
+ */
+export declare const HOST_KEY: unique symbol;
+/**
+ * Symbol para marcar qué campo recibe el componente host.
+ * Usado por @ComponentHost para inyectar el componente que contiene el behavior.
+ * Permite a behaviors acceder al contexto (@Ctx) del componente.
+ */
+export declare const COMPONENT_HOST_KEY: unique symbol;

package/dist/behaviors/constants.js

@@ -0,0 +1,8 @@
+const BEHAVIOR_PROPS = Symbol("behavior:props");
+const HOST_KEY = Symbol("behavior:host");
+const COMPONENT_HOST_KEY = Symbol("behavior:componentHost");
+export {
+  BEHAVIOR_PROPS,
+  COMPONENT_HOST_KEY,
+  HOST_KEY
+};