@hypen-space/core 0.4.92 → 0.4.941

package/dist/index.js

@@ -1941,8 +1941,207 @@ class HypenRouter {
   }
 }
 
+// src/managed-router.ts
+var log6 = createLogger("ManagedRouter");
+var DEFAULT_MAX_PERSISTED_MODULES = 10;
+
+class ManagedRouter {
+  router;
+  engine;
+  registry;
+  globalContext;
+  routes = [];
+  activeModule = null;
+  activeRoute = null;
+  unsubscribe = null;
+  persistedModules = new Map;
+  maxPersistedModules;
+  navPromise = Promise.resolve();
+  constructor(router, engine, registry, globalContext, options = {}) {
+    this.router = router;
+    this.engine = engine;
+    this.registry = registry;
+    this.globalContext = globalContext;
+    const cap = options.maxPersistedModules ?? DEFAULT_MAX_PERSISTED_MODULES;
+    this.maxPersistedModules = cap > 0 ? cap : DEFAULT_MAX_PERSISTED_MODULES;
+  }
+  addRoute(route) {
+    this.routes.push(route);
+    return this;
+  }
+  start() {
+    this.unsubscribe = this.router.onNavigate((routeState) => {
+      this.handleRouteChange(routeState);
+    });
+    this.installRouterActions();
+  }
+  installRouterActions() {
+    const router = this.router;
+    const defer = (fn) => queueMicrotask(fn);
+    const readTo = (action) => {
+      const payload = action?.payload;
+      const to = payload?.to;
+      return typeof to === "string" && to.length > 0 ? to : null;
+    };
+    this.engine.onAction("router.push", (action) => {
+      const to = readTo(action);
+      if (to)
+        defer(() => router.push(to));
+    });
+    this.engine.onAction("router.replace", (action) => {
+      const to = readTo(action);
+      if (to)
+        defer(() => router.replace(to));
+    });
+    this.engine.onAction("router.back", () => {
+      defer(() => router.back());
+    });
+    this.engine.onAction("router.forward", () => {
+      defer(() => router.forward());
+    });
+  }
+  async stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    const cleanup = this.navPromise.catch(() => {}).then(async () => {
+      await this.unmountActive();
+      for (const [moduleId, instance] of this.persistedModules) {
+        log6.debug(`Destroying persisted module on stop: ${moduleId}`);
+        try {
+          await instance.destroy();
+        } catch (e) {
+          log6.error(`Error destroying persisted module ${moduleId}:`, e);
+        }
+        this.globalContext.unregisterModule(moduleId);
+      }
+      this.persistedModules.clear();
+    });
+    this.navPromise = cleanup;
+    await cleanup;
+    this.router.dispose();
+  }
+  async waitForNavigation() {
+    try {
+      await this.navPromise;
+    } catch {}
+  }
+  getActiveModule() {
+    return this.activeModule;
+  }
+  getActiveRoute() {
+    return this.activeRoute;
+  }
+  handleRouteChange(routeState) {
+    this.navPromise = this.navPromise.catch((e) => {
+      log6.error("Previous navigation failed:", e);
+    }).then(() => this.processRouteChange(routeState));
+  }
+  async processRouteChange(routeState) {
+    const path = routeState.currentPath;
+    const matched = this.matchRoute(path);
+    if (!matched) {
+      log6.debug(`No route matched for path: ${path}`);
+      await this.unmountActive();
+      return;
+    }
+    if (this.activeRoute && this.activeRoute.path === matched.path) {
+      return;
+    }
+    await this.unmountActive();
+    await this.mount(matched);
+  }
+  matchRoute(path) {
+    for (const route of this.routes) {
+      if (this.router.matchPath(route.path, path) !== null) {
+        return route;
+      }
+    }
+    return null;
+  }
+  async mount(route) {
+    const definition = route.module || this.registry.get(route.component);
+    if (!definition) {
+      log6.debug(`No module definition found for component: ${route.component}`);
+      this.activeRoute = route;
+      return;
+    }
+    const namedDef = {
+      ...definition,
+      name: definition.name || route.component.toLowerCase()
+    };
+    const moduleId = namedDef.name.toLowerCase();
+    const persisted = this.persistedModules.get(moduleId);
+    if (persisted) {
+      log6.debug(`Restoring persisted module: ${moduleId} for route: ${route.path}`);
+      this.activeModule = persisted;
+      this.activeRoute = route;
+      this.persistedModules.delete(moduleId);
+      await persisted.activate();
+      return;
+    }
+    log6.debug(`Mounting module: ${namedDef.name} for route: ${route.path}`);
+    const instance = new HypenModuleInstance(this.engine, namedDef, this.router, this.globalContext);
+    this.globalContext.registerModule(moduleId, instance);
+    this.activeModule = instance;
+    this.activeRoute = route;
+    await instance.activate();
+  }
+  async unmountActive() {
+    if (!this.activeModule || !this.activeRoute) {
+      this.activeModule = null;
+      this.activeRoute = null;
+      return;
+    }
+    const active = this.activeModule;
+    const route = this.activeRoute;
+    const definition = route.module || this.registry.get(route.component);
+    const moduleId = (definition?.name || route.component).toLowerCase();
+    const persist = definition != null && definition.persist !== false;
+    this.activeModule = null;
+    this.activeRoute = null;
+    try {
+      await active.deactivate();
+    } catch (e) {
+      log6.error(`Error deactivating module ${moduleId}:`, e);
+    }
+    if (persist) {
+      log6.debug(`Persisting module: ${moduleId}`);
+      this.persistedModules.delete(moduleId);
+      this.persistedModules.set(moduleId, active);
+      await this.evictPersistedOverflow();
+    } else {
+      log6.debug(`Unmounting module: ${moduleId}`);
+      try {
+        await active.destroy();
+      } catch (e) {
+        log6.error(`Error destroying module ${moduleId}:`, e);
+      }
+      this.globalContext.unregisterModule(moduleId);
+    }
+  }
+  async evictPersistedOverflow() {
+    while (this.persistedModules.size > this.maxPersistedModules) {
+      const oldest = this.persistedModules.keys().next();
+      if (oldest.done)
+        break;
+      const oldestId = oldest.value;
+      const evicted = this.persistedModules.get(oldestId);
+      this.persistedModules.delete(oldestId);
+      log6.debug(`Evicting persisted module (LRU): ${oldestId}`);
+      try {
+        await evicted.destroy();
+      } catch (e) {
+        log6.error(`Error destroying evicted module ${oldestId}:`, e);
+      }
+      this.globalContext.unregisterModule(oldestId);
+    }
+  }
+}
+
 // src/events.ts
-var log6 = frameworkLoggers.events;
+var log7 = frameworkLoggers.events;
 
 class TypedEventEmitter {
   eventBus = new Map;
@@ -1955,7 +2154,7 @@ class TypedEventEmitter {
       try {
         handler(payload);
       } catch (error) {
-        log6.error(`Error in event handler for "${String(event)}":`, error);
+        log7.error(`Error in event handler for "${String(event)}":`, error);
       }
     });
   }
@@ -2007,7 +2206,7 @@ function createEventEmitter() {
 }
 
 // src/context.ts
-var log7 = frameworkLoggers.context;
+var log8 = frameworkLoggers.context;
 
 class HypenGlobalContext {
   modules = new Map;
@@ -2020,14 +2219,14 @@ class HypenGlobalContext {
   }
   registerModule(id, instance) {
     if (this.modules.has(id)) {
-      log7.warn(`Module "${id}" is already registered. Overwriting.`);
+      log8.warn(`Module "${id}" is already registered. Overwriting.`);
     }
     this.modules.set(id, instance);
-    log7.debug(`Registered module: ${id}`);
+    log8.debug(`Registered module: ${id}`);
   }
   unregisterModule(id) {
     this.modules.delete(id);
-    log7.debug(`Unregistered module: ${id}`);
+    log8.debug(`Unregistered module: ${id}`);
   }
   getModule(id) {
     const module = this.modules.get(id);
@@ -2055,14 +2254,14 @@ class HypenGlobalContext {
   }
   emit(event, payload) {
     if (this.typedEvents.listenerCount(event) === 0) {
-      log7.debug(`Event "${event}" emitted but no listeners`);
+      log8.debug(`Event "${event}" emitted but no listeners`);
       return;
     }
-    log7.debug(`Emitting event: ${event}`, payload);
+    log8.debug(`Emitting event: ${event}`, payload);
     this.typedEvents.emit(event, payload);
   }
   on(event, handler) {
-    log7.debug(`Listening to event: ${event}`);
+    log8.debug(`Listening to event: ${event}`);
     return this.typedEvents.on(event, handler);
   }
   off(event, handler) {
@@ -2209,7 +2408,7 @@ var RetryPresets = {
 };
 
 // src/remote/client.ts
-var log8 = frameworkLoggers.remote;
+var log9 = frameworkLoggers.remote;
 
 class RemoteEngine {
   ws = null;
@@ -2338,7 +2537,7 @@ class RemoteEngine {
     this.navigationDisposable = disposableListener(window, "popstate", () => {
       if (this.handlingPopState)
         return;
-      log8.debug("Back navigation detected, dispatching:", nav.backAction);
+      log9.debug("Back navigation detected, dispatching:", nav.backAction);
       this.handlingPopState = true;
       this.dispatchAction(nav.backAction);
     });
@@ -2374,7 +2573,7 @@ class RemoteEngine {
   }
   dispatchAction(action, payload) {
     if (this.state !== "connected" || !this.ws) {
-      log8.warn("Cannot dispatch action: not connected");
+      log9.warn("Cannot dispatch action: not connected");
       return;
     }
     const message = {
@@ -2387,7 +2586,7 @@ class RemoteEngine {
   }
   subscribeState() {
     if (this.state !== "connected" || !this.ws) {
-      log8.warn("Cannot subscribe to state: not connected");
+      log9.warn("Cannot subscribe to state: not connected");
       return;
     }
     const message = { type: "subscribeState" };
@@ -2395,7 +2594,7 @@ class RemoteEngine {
   }
   updateState(state2) {
     if (this.state !== "connected" || !this.ws) {
-      log8.warn("Cannot update state: not connected");
+      log9.warn("Cannot update state: not connected");
       return;
     }
     const message = {
@@ -2468,7 +2667,7 @@ class RemoteEngine {
           break;
       }
     } catch (e) {
-      log8.error("Error handling remote message:", e);
+      log9.error("Error handling remote message:", e);
       const error = e instanceof Error ? e : new Error(String(e));
       this.errorCallbacks.forEach((cb) => cb(error));
     }
@@ -2502,7 +2701,7 @@ class RemoteEngine {
   }
   handlePatch(message) {
     if (message.revision <= this.currentRevision) {
-      log8.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
+      log9.warn(`Out of order patch: expected > ${this.currentRevision}, got ${message.revision}`);
       return;
     }
     this.currentRevision = message.revision;
@@ -2528,10 +2727,10 @@ class RemoteEngine {
         maxDelayMs: 30000,
         jitter: 0.1,
         onRetry: (attempt, error) => {
-          log8.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
+          log9.debug(`Reconnection attempt ${attempt}/${this.options.maxReconnectAttempts} failed: ${error.message}`);
         }
       }).catch((error) => {
-        log8.error("Max reconnection attempts reached:", error.message);
+        log9.error("Max reconnection attempts reached:", error.message);
         this.errorCallbacks.forEach((cb) => cb(new ConnectionError(this.url, error, this.options.maxReconnectAttempts)));
       });
     }, this.options.reconnectInterval);
@@ -2784,7 +2983,7 @@ class ComponentResolver {
 }
 
 // src/components/builtin.ts
-var log9 = frameworkLoggers.router;
+var log10 = frameworkLoggers.router;
 async function updateRouteVisibility(currentPath, engine, doc) {
   const targetDoc = doc ?? document;
   const routeElements = targetDoc.querySelectorAll('[data-hypen-type="route"]');
@@ -2805,13 +3004,13 @@ async function updateRouteVisibility(currentPath, engine, doc) {
         try {
           await engine.renderLazyRoute(routePath, componentName, htmlEl);
         } catch (err) {
-          log9.error(`Failed to render route ${routePath}:`, err);
+          log10.error(`Failed to render route ${routePath}:`, err);
         }
       }
     }
   }
   if (!matchFound) {
-    log9.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
+    log10.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
   }
 }
 var Router = app.defineState({
@@ -2820,12 +3019,12 @@ var Router = app.defineState({
   routeParams: {}
 }, { name: "__Router" }).onCreated((state2, context) => {
   if (!context) {
-    log9.error("Requires global context");
+    log10.error("Requires global context");
     return;
   }
   const router = context.router;
   if (!router) {
-    log9.error("Router not found in context");
+    log10.error("Router not found in context");
     return;
   }
   const hypenEngine = context.__hypenEngine;
@@ -2845,7 +3044,7 @@ var Link = app.defineState({
 }, { name: "__Link" }).onAction("navigate", ({ state: state2, context }) => {
   const router = context?.router;
   if (!router) {
-    log9.error("Link requires router context");
+    log10.error("Link requires router context");
     return;
   }
   const targetPath = state2.to;
@@ -2860,204 +3059,6 @@ var Link = app.defineState({
     });
   }
 }).build();
-// src/managed-router.ts
-var log10 = createLogger("ManagedRouter");
-var DEFAULT_MAX_PERSISTED_MODULES = 10;
-
-class ManagedRouter {
-  router;
-  engine;
-  registry;
-  globalContext;
-  routes = [];
-  activeModule = null;
-  activeRoute = null;
-  unsubscribe = null;
-  persistedModules = new Map;
-  maxPersistedModules;
-  navPromise = Promise.resolve();
-  constructor(router, engine, registry, globalContext, options = {}) {
-    this.router = router;
-    this.engine = engine;
-    this.registry = registry;
-    this.globalContext = globalContext;
-    const cap = options.maxPersistedModules ?? DEFAULT_MAX_PERSISTED_MODULES;
-    this.maxPersistedModules = cap > 0 ? cap : DEFAULT_MAX_PERSISTED_MODULES;
-  }
-  addRoute(route) {
-    this.routes.push(route);
-    return this;
-  }
-  start() {
-    this.unsubscribe = this.router.onNavigate((routeState) => {
-      this.handleRouteChange(routeState);
-    });
-    this.installRouterActions();
-  }
-  installRouterActions() {
-    const router = this.router;
-    const defer = (fn) => queueMicrotask(fn);
-    const readTo = (action) => {
-      const payload = action?.payload;
-      const to = payload?.to;
-      return typeof to === "string" && to.length > 0 ? to : null;
-    };
-    this.engine.onAction("router.push", (action) => {
-      const to = readTo(action);
-      if (to)
-        defer(() => router.push(to));
-    });
-    this.engine.onAction("router.replace", (action) => {
-      const to = readTo(action);
-      if (to)
-        defer(() => router.replace(to));
-    });
-    this.engine.onAction("router.back", () => {
-      defer(() => router.back());
-    });
-    this.engine.onAction("router.forward", () => {
-      defer(() => router.forward());
-    });
-  }
-  async stop() {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = null;
-    }
-    const cleanup = this.navPromise.catch(() => {}).then(async () => {
-      await this.unmountActive();
-      for (const [moduleId, instance] of this.persistedModules) {
-        log10.debug(`Destroying persisted module on stop: ${moduleId}`);
-        try {
-          await instance.destroy();
-        } catch (e) {
-          log10.error(`Error destroying persisted module ${moduleId}:`, e);
-        }
-        this.globalContext.unregisterModule(moduleId);
-      }
-      this.persistedModules.clear();
-    });
-    this.navPromise = cleanup;
-    await cleanup;
-    this.router.dispose();
-  }
-  async waitForNavigation() {
-    try {
-      await this.navPromise;
-    } catch {}
-  }
-  getActiveModule() {
-    return this.activeModule;
-  }
-  getActiveRoute() {
-    return this.activeRoute;
-  }
-  handleRouteChange(routeState) {
-    this.navPromise = this.navPromise.catch((e) => {
-      log10.error("Previous navigation failed:", e);
-    }).then(() => this.processRouteChange(routeState));
-  }
-  async processRouteChange(routeState) {
-    const path = routeState.currentPath;
-    const matched = this.matchRoute(path);
-    if (!matched) {
-      log10.debug(`No route matched for path: ${path}`);
-      await this.unmountActive();
-      return;
-    }
-    if (this.activeRoute && this.activeRoute.path === matched.path) {
-      return;
-    }
-    await this.unmountActive();
-    await this.mount(matched);
-  }
-  matchRoute(path) {
-    for (const route of this.routes) {
-      if (this.router.matchPath(route.path, path) !== null) {
-        return route;
-      }
-    }
-    return null;
-  }
-  async mount(route) {
-    const definition = route.module || this.registry.get(route.component);
-    if (!definition) {
-      log10.debug(`No module definition found for component: ${route.component}`);
-      this.activeRoute = route;
-      return;
-    }
-    const namedDef = {
-      ...definition,
-      name: definition.name || route.component.toLowerCase()
-    };
-    const moduleId = namedDef.name.toLowerCase();
-    const persisted = this.persistedModules.get(moduleId);
-    if (persisted) {
-      log10.debug(`Restoring persisted module: ${moduleId} for route: ${route.path}`);
-      this.activeModule = persisted;
-      this.activeRoute = route;
-      this.persistedModules.delete(moduleId);
-      await persisted.activate();
-      return;
-    }
-    log10.debug(`Mounting module: ${namedDef.name} for route: ${route.path}`);
-    const instance = new HypenModuleInstance(this.engine, namedDef, this.router, this.globalContext);
-    this.globalContext.registerModule(moduleId, instance);
-    this.activeModule = instance;
-    this.activeRoute = route;
-    await instance.activate();
-  }
-  async unmountActive() {
-    if (!this.activeModule || !this.activeRoute) {
-      this.activeModule = null;
-      this.activeRoute = null;
-      return;
-    }
-    const active = this.activeModule;
-    const route = this.activeRoute;
-    const definition = route.module || this.registry.get(route.component);
-    const moduleId = (definition?.name || route.component).toLowerCase();
-    const persist = definition != null && definition.persist !== false;
-    this.activeModule = null;
-    this.activeRoute = null;
-    try {
-      await active.deactivate();
-    } catch (e) {
-      log10.error(`Error deactivating module ${moduleId}:`, e);
-    }
-    if (persist) {
-      log10.debug(`Persisting module: ${moduleId}`);
-      this.persistedModules.delete(moduleId);
-      this.persistedModules.set(moduleId, active);
-      await this.evictPersistedOverflow();
-    } else {
-      log10.debug(`Unmounting module: ${moduleId}`);
-      try {
-        await active.destroy();
-      } catch (e) {
-        log10.error(`Error destroying module ${moduleId}:`, e);
-      }
-      this.globalContext.unregisterModule(moduleId);
-    }
-  }
-  async evictPersistedOverflow() {
-    while (this.persistedModules.size > this.maxPersistedModules) {
-      const oldest = this.persistedModules.keys().next();
-      if (oldest.done)
-        break;
-      const oldestId = oldest.value;
-      const evicted = this.persistedModules.get(oldestId);
-      this.persistedModules.delete(oldestId);
-      log10.debug(`Evicting persisted module (LRU): ${oldestId}`);
-      try {
-        await evicted.destroy();
-      } catch (e) {
-        log10.error(`Error destroying evicted module ${oldestId}:`, e);
-      }
-      this.globalContext.unregisterModule(oldestId);
-    }
-  }
-}
 export {
   withRetry,
   usingSync,
@@ -3143,4 +3144,4 @@ export {
   ActionError
 };
 
-//# debugId=A9CE0B874F21F46D64756E2164756E21
+//# debugId=6ED7F94267EF229064756E2164756E21