@v-ibe/core 0.1.0

package/dist/data-management/store/store.d.ts

@@ -0,0 +1,108 @@
+import { Constructor, Predicate, QueryResult, ModelMetadata } from './types';
+/**
+ * Registra metadata para un modelo
+ * Llamado por el decorador @Model
+ */
+export declare function registerModelMetadata(metadata: ModelMetadata): void;
+/**
+ * Obtiene metadata de un modelo
+ */
+export declare function getModelMetadata(modelClass: Constructor): ModelMetadata | undefined;
+/**
+ * EntityStore - Almacén central normalizado de todas las entidades
+ */
+export declare class EntityStore {
+    /**
+     * Estructura de almacenamiento principal
+     * Map<TipoDeModelo, Map<ID, Instancia>>
+     *
+     * Ejemplo:
+     * entities.get(User) -> Map { "123" -> userInstance }
+     */
+    private entities;
+    /**
+     * Sistema de notificación para queries reactivas
+     * Map<TipoDeModelo, Signal<number>>
+     *
+     * Cada tipo de modelo tiene una signal que se incrementa cuando hay cambios.
+     * Las queries reactivas se suscriben a esta signal.
+     */
+    private changeNotifiers;
+    /**
+     * Obtiene entidades que coinciden con un predicado
+     *
+     * @param modelClass - La clase del modelo (ej: User, Article)
+     * @param predicate - Función que retorna true para items que quieres
+     * @returns Array de instancias que pasaron el predicado
+     *
+     * REACTIVIDAD:
+     * Si se llama dentro de un contexto reactivo (ej: dentro de @Store),
+     * el resultado se actualizará automáticamente cuando el Store cambie.
+     *
+     * @example
+     * // Snapshot estático (no reactivo)
+     * const users = store.get(User, u => u.isActive);
+     *
+     * @example
+     * // Reactivo (cuando se usa con @Store)
+     * @Store
+     * activeUsers = store.get(User, u => u.isActive);
+     */
+    get<T>(modelClass: Constructor<T>, predicate: Predicate<T>): QueryResult<T>;
+    /**
+     * Almacena una o más entidades en el Store
+     * Si la entidad ya existe (mismo ID), se actualiza
+     *
+     * @param modelClass - La clase del modelo
+     * @param data - Una entidad o array de entidades
+     *
+     * @example
+     * // Almacenar un usuario
+     * store.set(User, userInstance);
+     *
+     * @example
+     * // Almacenar múltiples usuarios
+     * store.set(User, [user1, user2, user3]);
+     */
+    set<T>(modelClass: Constructor<T>, data: T | T[]): void;
+    /**
+     * Elimina una entidad del Store
+     *
+     * @param modelClass - La clase del modelo
+     * @param id - El ID de la entidad a eliminar
+     * @returns true si se eliminó, false si no existía
+     */
+    delete<T>(modelClass: Constructor<T>, id: string): boolean;
+    /**
+     * Limpia todas las entidades de un tipo de modelo
+     *
+     * @param modelClass - La clase del modelo a limpiar
+     */
+    clear<T>(modelClass: Constructor<T>): void;
+    /**
+     * Limpia TODO el Store
+     */
+    clearAll(): void;
+    /**
+     * Obtiene el conteo de entidades de un tipo
+     */
+    count<T>(modelClass: Constructor<T>): number;
+    /**
+     * Obtiene o crea la signal de notificación para un tipo de modelo.
+     * Esta signal se incrementa cada vez que hay cambios en ese tipo.
+     *
+     * @private
+     */
+    private getChangeNotifier;
+    /**
+     * Notifica que hubo un cambio en un tipo de modelo.
+     * Esto triggerea la re-evaluación de todas las queries reactivas de ese tipo.
+     *
+     * @private
+     */
+    private notifyChange;
+    /**
+     * Debug: Muestra el estado actual del EntityStore
+     */
+    debug(): void;
+}

package/dist/data-management/store/store.js

@@ -0,0 +1,207 @@
+import { Signal } from "../../reactivity/signals/signal.js";
+import { Service } from "../../DI/decorators/service.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 _EntityStore_decorators, _init;
+const modelMetadataRegistry = /* @__PURE__ */ new Map();
+function registerModelMetadata(metadata) {
+  modelMetadataRegistry.set(metadata.modelClass, metadata);
+}
+function getModelMetadata(modelClass) {
+  return modelMetadataRegistry.get(modelClass);
+}
+_EntityStore_decorators = [Service];
+class EntityStore {
+  constructor() {
+    this.entities = /* @__PURE__ */ new Map();
+    this.changeNotifiers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Obtiene entidades que coinciden con un predicado
+   *
+   * @param modelClass - La clase del modelo (ej: User, Article)
+   * @param predicate - Función que retorna true para items que quieres
+   * @returns Array de instancias que pasaron el predicado
+   *
+   * REACTIVIDAD:
+   * Si se llama dentro de un contexto reactivo (ej: dentro de @Store),
+   * el resultado se actualizará automáticamente cuando el Store cambie.
+   *
+   * @example
+   * // Snapshot estático (no reactivo)
+   * const users = store.get(User, u => u.isActive);
+   *
+   * @example
+   * // Reactivo (cuando se usa con @Store)
+   * @Store
+   * activeUsers = store.get(User, u => u.isActive);
+   */
+  get(modelClass, predicate) {
+    const changeNotifier = this.getChangeNotifier(modelClass);
+    changeNotifier.get();
+    const entityMap = this.entities.get(modelClass);
+    if (!entityMap) {
+      return [];
+    }
+    const allEntities = Array.from(entityMap.values());
+    return allEntities.filter(predicate);
+  }
+  /**
+   * Almacena una o más entidades en el Store
+   * Si la entidad ya existe (mismo ID), se actualiza
+   *
+   * @param modelClass - La clase del modelo
+   * @param data - Una entidad o array de entidades
+   *
+   * @example
+   * // Almacenar un usuario
+   * store.set(User, userInstance);
+   *
+   * @example
+   * // Almacenar múltiples usuarios
+   * store.set(User, [user1, user2, user3]);
+   */
+  set(modelClass, data) {
+    const metadata = getModelMetadata(modelClass);
+    if (!metadata) {
+      throw new Error(
+        `No metadata found for ${modelClass.name}. Did you forget @Model decorator?`
+      );
+    }
+    const entities = Array.isArray(data) ? data : [data];
+    if (!this.entities.has(modelClass)) {
+      this.entities.set(modelClass, /* @__PURE__ */ new Map());
+    }
+    const entityMap = this.entities.get(modelClass);
+    for (const entity of entities) {
+      const id = entity[metadata.idField];
+      if (id === void 0 || id === null) {
+        console.warn(
+          `Entity of type ${modelClass.name} has no ID field '${metadata.idField}'. Skipping.`,
+          entity
+        );
+        continue;
+      }
+      entityMap.set(String(id), entity);
+    }
+    this.notifyChange(modelClass);
+  }
+  /**
+   * Elimina una entidad del Store
+   *
+   * @param modelClass - La clase del modelo
+   * @param id - El ID de la entidad a eliminar
+   * @returns true si se eliminó, false si no existía
+   */
+  delete(modelClass, id) {
+    const entityMap = this.entities.get(modelClass);
+    if (!entityMap) {
+      return false;
+    }
+    const result = entityMap.delete(id);
+    if (result) {
+      this.notifyChange(modelClass);
+    }
+    return result;
+  }
+  /**
+   * Limpia todas las entidades de un tipo de modelo
+   *
+   * @param modelClass - La clase del modelo a limpiar
+   */
+  clear(modelClass) {
+    const entityMap = this.entities.get(modelClass);
+    if (entityMap && entityMap.size > 0) {
+      this.entities.delete(modelClass);
+      this.notifyChange(modelClass);
+    }
+  }
+  /**
+   * Limpia TODO el Store
+   */
+  clearAll() {
+    for (const modelClass of this.entities.keys()) {
+      this.notifyChange(modelClass);
+    }
+    this.entities.clear();
+  }
+  /**
+   * Obtiene el conteo de entidades de un tipo
+   */
+  count(modelClass) {
+    const entityMap = this.entities.get(modelClass);
+    return entityMap ? entityMap.size : 0;
+  }
+  /**
+   * Obtiene o crea la signal de notificación para un tipo de modelo.
+   * Esta signal se incrementa cada vez que hay cambios en ese tipo.
+   *
+   * @private
+   */
+  getChangeNotifier(modelClass) {
+    if (!this.changeNotifiers.has(modelClass)) {
+      this.changeNotifiers.set(modelClass, new Signal(0));
+    }
+    return this.changeNotifiers.get(modelClass);
+  }
+  /**
+   * Notifica que hubo un cambio en un tipo de modelo.
+   * Esto triggerea la re-evaluación de todas las queries reactivas de ese tipo.
+   *
+   * @private
+   */
+  notifyChange(modelClass) {
+    const notifier = this.getChangeNotifier(modelClass);
+    notifier.update((n) => n + 1);
+  }
+  /**
+   * Debug: Muestra el estado actual del EntityStore
+   */
+  debug() {
+    console.log("=== ENTITY STORE DEBUG ===");
+    for (const [modelClass, entityMap] of this.entities) {
+      console.log(`${modelClass.name}: ${entityMap.size} entities`);
+      for (const [id, entity] of entityMap) {
+        console.log(`  - ${id}:`, entity);
+      }
+    }
+    console.log("=========================");
+  }
+}
+_init = __decoratorStart();
+EntityStore = __decorateElement(_init, 0, "EntityStore", _EntityStore_decorators, EntityStore);
+__runInitializers(_init, 1, EntityStore);
+export {
+  EntityStore,
+  getModelMetadata,
+  registerModelMetadata
+};

package/dist/data-management/store/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * TYPES.TS - Tipos fundamentales del Data Management System
+ *
+ * Este archivo define los tipos core que todo el sistema usará.
+ */
+/**
+ * Constructor type - cualquier clase que pueda ser instanciada
+ */
+export type Constructor<T = any> = new (...args: any[]) => T;
+/**
+ * Metadata que cada @Model class tendrá
+ * Esta metadata se registra cuando usas el decorador @Model
+ */
+export interface ModelMetadata {
+    /**
+     * La clase del modelo (ej: User, Article)
+     */
+    modelClass: Constructor;
+    /**
+     * El nombre del campo que es el ID (ej: 'id', 'userId', '_id')
+     * Se determina por el decorador @Id
+     */
+    idField: string;
+    /**
+     * Nombres de los campos que son propiedades reactivas
+     * Se determinan por el decorador @Prop
+     */
+    propFields: string[];
+}
+/**
+ * Una entidad almacenada en el Store
+ * Cada instancia de un @Model es una StoreEntity
+ */
+export interface StoreEntity {
+    /**
+     * El ID único de esta entidad
+     * Extraído del campo marcado con @Id
+     */
+    [id: string]: any;
+}
+/**
+ * Función predicado para queries
+ * Ejemplos:
+ *   - u => u.id === '123'
+ *   - u => u.name.startsWith('A')
+ *   - u => u.age > 18
+ */
+export type Predicate<T> = (item: T) => boolean;
+/**
+ * El resultado de una query al Store
+ * Por ahora es solo un array, pero eventualmente será reactivo
+ */
+export type QueryResult<T> = T[];

package/dist/events-handler/decorators/emit.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Configuración opcional para el decorador @Emit
+ */
+export interface EmitOptions {
+    /** Nombre personalizado del evento. Si no se especifica, se infiere del nombre del método */
+    eventName?: string;
+    /** Si el evento debe burbujear (bubble) por el DOM tree. Por defecto: true */
+    bubbles?: boolean;
+    /** Si el evento puede ser cancelado. Por defecto: true */
+    cancelable?: boolean;
+    /** Si se debe retornar el CustomEvent creado para permitir verificar preventDefault(). Por defecto: false */
+    returnEvent?: boolean;
+}
+/**
+ * @Emit es un decorador para métodos que automáticamente convierte su valor
+ * de retorno en un CustomEvent que se despacha desde el componente.
+ *
+ * Ejemplo de uso:
+ * @Emit
+ * onUserSelect() {
+ *   return { name: this.name, id: this.id };
+ * }
+ *
+ * Esto automáticamente:
+ * 1. Crea un CustomEvent llamado 'userselect'
+ * 2. Coloca el objeto retornado en event.detail
+ * 3. Despacha el evento desde el elemento del componente
+ */
+export declare function Emit(options?: EmitOptions): <This extends HTMLElement, Return>(target: (this: This, ...args: any[]) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: any[]) => Return>) => void;

package/dist/events-handler/decorators/emit.js

@@ -0,0 +1,51 @@
+function Emit(options = {}) {
+  return function(target, context) {
+    if (context.kind !== "method") {
+      throw new Error("@Emit solo se puede aplicar a métodos de clase.");
+    }
+    const methodName = String(context.name);
+    const defaultEventName = inferEventName(methodName);
+    const config = {
+      eventName: options.eventName ?? defaultEventName,
+      bubbles: options.bubbles ?? true,
+      cancelable: options.cancelable ?? true,
+      returnEvent: options.returnEvent ?? false
+    };
+    context.addInitializer(function() {
+      const originalMethod = target;
+      const enhancedMethod = function(...args) {
+        const eventData = originalMethod.call(this, ...args);
+        const customEvent = new CustomEvent(config.eventName, {
+          detail: eventData,
+          bubbles: config.bubbles,
+          cancelable: config.cancelable
+        });
+        this.dispatchEvent(customEvent);
+        if (config.returnEvent) {
+          return customEvent;
+        }
+        return eventData;
+      };
+      Object.defineProperty(this, context.name, {
+        value: enhancedMethod,
+        writable: true,
+        enumerable: false,
+        // No mostrar en enumeraciones
+        configurable: true
+        // Permitir futuras modificaciones si es necesario
+      });
+    });
+  };
+}
+function inferEventName(methodName) {
+  if (methodName.startsWith("on") && methodName.length > 2) {
+    const thirdChar = methodName.charAt(2);
+    if (thirdChar === thirdChar.toUpperCase()) {
+      return methodName.substring(2).toLowerCase();
+    }
+  }
+  return methodName.toLowerCase();
+}
+export {
+  Emit
+};

package/dist/events-handler/event-decorators.d.ts

@@ -0,0 +1 @@
+export declare function On(eventType: string): (originalMethod: any, context: ClassMethodDecoratorContext) => any;

package/dist/events-handler/event-emitter.service.d.ts

@@ -0,0 +1,21 @@
+import { EventListenerMetadata } from './event-types';
+import { Constructor } from '../DI/types.ts';
+/**
+ * EventEmitter service that uses native EventTarget for event handling
+ * This service manages event emission only. Registration is handled by the DI container.
+ */
+export declare class EventEmitter {
+    private eventTarget;
+    private registeredHandlers;
+    constructor();
+    /**
+     * Register an event listener for a class and set up the handler immediately
+     */
+    registerEventListener(target: Constructor, metadata: EventListenerMetadata): void;
+    /**
+     * Emit an event to all registered listeners
+     * @param eventType - The type of event to emit
+     * @param eventData - The event data (can be any type)
+     */
+    emit<T = any>(eventType: string, eventData: T): void;
+}

package/dist/events-handler/event-emitter.service.js

@@ -0,0 +1,85 @@
+import { Service } from "../DI/decorators/service.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 _EventEmitter_decorators, _init;
+class CustomEvent extends Event {
+  constructor(eventType, eventData) {
+    super(eventType);
+    this.eventData = eventData;
+  }
+}
+_EventEmitter_decorators = [Service];
+class EventEmitter {
+  constructor() {
+    this.eventTarget = void 0;
+    this.registeredHandlers = /* @__PURE__ */ new Set();
+    this.eventTarget = new EventTarget();
+  }
+  /**
+   * Register an event listener for a class and set up the handler immediately
+   */
+  registerEventListener(target, metadata) {
+    const handlerId = `${target.name}-${metadata.eventType}-${String(metadata.methodName)}`;
+    if (this.registeredHandlers.has(handlerId)) {
+      return;
+    }
+    this.eventTarget.addEventListener(metadata.eventType, async (event) => {
+      if (event instanceof CustomEvent) {
+        try {
+          const serviceInstance = this.__container.get(target);
+          const handler = serviceInstance[metadata.methodName];
+          if (typeof handler === "function") {
+            await handler.call(serviceInstance, event.eventData);
+          }
+        } catch (error) {
+          console.error(`Error executing event handler ${handlerId}:`, error);
+        }
+      }
+    });
+    this.registeredHandlers.add(handlerId);
+  }
+  /**
+   * Emit an event to all registered listeners
+   * @param eventType - The type of event to emit
+   * @param eventData - The event data (can be any type)
+   */
+  emit(eventType, eventData) {
+    const customEvent = new CustomEvent(eventType, eventData);
+    this.eventTarget.dispatchEvent(customEvent);
+  }
+}
+_init = __decoratorStart();
+EventEmitter = __decorateElement(_init, 0, "EventEmitter", _EventEmitter_decorators, EventEmitter);
+__runInitializers(_init, 1, EventEmitter);
+export {
+  EventEmitter
+};

package/dist/events-handler/event-types.d.ts

@@ -0,0 +1,12 @@
+import { Constructor } from '../DI/types.ts';
+/**
+ * Event listener metadata stored by decorators
+ */
+export interface EventListenerMetadata {
+    /** Event type to listen for */
+    eventType: string;
+    /** Method name that handles the event */
+    methodName: string | symbol;
+    /** Target class constructor */
+    target: Constructor;
+}

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+declare global {
+    namespace JSX {
+        type Element = any;
+        interface IntrinsicElements {
+            [elemName: string]: any;
+        }
+    }
+}
+export { BaseComponent } from './components/base-component';
+export { Component } from './components/decorators/component';
+export { Prop } from './components/decorators/prop';
+export { Param, Params, Query, QueryParams, Allow, Block, Redirect, Skip, getPolicyRules } from './router/decorators';
+export type { ParamMetadata, QueryParamMetadata, RouteConfig, PolicyDecisionType, PolicyRule, PolicyDecision } from './router/decorators';
+export { State } from './reactivity/decorators/state';
+export { Effect } from './reactivity/decorators/effect';
+export { Computed } from './reactivity/decorators/computed';
+export { Resource } from './reactivity/decorators/resource';
+export { Store } from './reactivity/decorators/store';
+export { RouteMetadata } from './router/decorators/route-metadata';
+export type { IResource } from './reactivity/signals/resource';
+export { Ctx } from './reactivity/decorators/ctx';
+export { collection, isObservableArray, isCollection, isReactiveArrayLike, unwrapReactiveArray } from './reactivity/signals/reactive-array';
+export type { ObservableArray, Collection } from './reactivity/signals/reactive-array';
+export { Emit } from './events-handler/decorators/emit';
+export { BaseStyleSheet } from './styles/base-style-sheet';
+export { Style } from './styles/decorators/style';
+export { Service } from './DI/decorators/service';
+export { Inject } from './DI/decorators/inject';
+export type { LifeCycle } from './DI/lifecycle';
+export { DIContainer } from './DI/di-container';
+export { ScopedContainer } from './DI/scoped-container';
+export { registerServiceMetadata, getServiceMetadata, getAllServiceMetadata, clearServiceMetadata } from './DI/service-metadata';
+export type { ServiceMetadata } from './DI/service-metadata';
+export { core } from './core';
+export { Rule } from './styles/decorators/rule';
+export type { CSSProperties } from './styles/decorators/rule';
+export { UseStyles } from './styles/decorators/useStyles';
+export { Behavior, Host, ComponentHost } from './behaviors';
+export { MediaQuery } from './styles/decorators/factories';
+export { Shared, ForDocument } from './styles/decorators/scope';
+export type { StyleScope } from './styles/decorators/scope';
+export { Keyframes } from './styles/decorators/keyframes';
+export type { KeyframesDefinition, KeyframeSelector } from './styles/decorators/keyframes';
+export { jsxContextualPlugin } from './vite-plugins/jsx-contextual';
+export { jsxSignalsPlugin } from './vite-plugins/jsx-signals';
+export { Router } from './router/router';
+export { Route } from './router/decorators';
+export { Trie } from './router/trie';
+export { RouteView } from './router/route-view';
+export { Link } from './router/link.behavior';
+export { Id, Model, Prop as Field, EntityStore, Consume, MemoryCache, LocalStorageCache, SessionStorageCache, Cache, TTL, CacheTags, CacheUpdate, CacheInvalidate } from './data-management';
+export type { CacheProvider, CacheEntry, TagExtractor } from './data-management';
+export { For, Show } from './custom-components';
+export type { ForProps, ShowProps } from './custom-components';
+export { ReactiveArray } from './reactivity/signals/reactive-array';