@hypen-space/core 0.4.32 → 0.4.35

package/dist/index.d.ts

@@ -44,7 +44,9 @@ export type { Patch, Action, RenderCallback, ActionHandler as EngineActionHandle
 export { app, HypenApp, HypenAppBuilder, HypenModuleInstance } from "./app.js";
 export { hypen, state, item, index } from "./hypen.js";
 export type { StateProxy, ItemProxy } from "./hypen.js";
-export type { IEngine, ActionContext, GlobalContext, LifecycleHandler, ActionHandlerContext, ActionHandler, HypenModuleDefinition, HypenModule, DisconnectContext, ReconnectContext, ExpireContext, DisconnectHandler, ReconnectHandler, ExpireHandler, ErrorContext, ErrorHandler, ErrorHandlerResult, } from "./app.js";
+export type { IEngine, ActionContext, GlobalContext, LifecycleHandler, ActionHandlerContext, ActionHandler, HypenModuleDefinition, HypenModule, DisconnectContext, ReconnectContext, ExpireContext, DisconnectHandler, ReconnectHandler, ExpireHandler, ErrorContext, ErrorHandler, ErrorHandlerResult, DataSourceAccessor, } from "./app.js";
+export { DataSourceManager } from "./datasource.js";
+export type { DataSourcePlugin, DataSourceStatus, DataSourceQuery, DataSourceSubscription, DataSourceChange, IDataSourceEngine, } from "./datasource.js";
 export { createObservableState, batchStateUpdates, getStateSnapshot, isStateProxy, unwrapProxy, } from "./state.js";
 export type { StatePath, StateChange, StateObserverOptions, } from "./state.js";
 export { BaseRenderer, ConsoleRenderer } from "./renderer.js";

package/dist/index.js

@@ -1,12 +1,16 @@
 import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -182,6 +186,59 @@ var init_result = __esm(() => {
   };
 });
 
+// src/datasource.ts
+class DataSourceManager {
+  plugins = new Map;
+  configs = new Map;
+  state = new Map;
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  async use(plugin, config) {
+    const { name } = plugin;
+    this.state.set(name, {});
+    this.plugins.set(name, plugin);
+    this.configs.set(name, config);
+    await plugin.connect(config, (change) => {
+      const current = this.state.get(name) ?? {};
+      for (const path of change.paths) {
+        if (path in change.values) {
+          current[path] = change.values[path];
+        }
+      }
+      this.state.set(name, current);
+      this.engine.setContext(name, current);
+    });
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  has(name) {
+    return this.plugins.has(name);
+  }
+  getNames() {
+    return Array.from(this.plugins.keys());
+  }
+  getStatus(name) {
+    return this.plugins.get(name)?.status;
+  }
+  async remove(name) {
+    const plugin = this.plugins.get(name);
+    if (plugin) {
+      await plugin.disconnect();
+      this.plugins.delete(name);
+      this.configs.delete(name);
+      this.state.delete(name);
+      this.engine.removeContext(name);
+    }
+  }
+  async disconnectAll() {
+    const names = Array.from(this.plugins.keys());
+    await Promise.all(names.map((name) => this.remove(name)));
+  }
+}
+
 // src/state.ts
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
@@ -321,9 +378,11 @@ function createObservableState(initialState, options) {
           notificationPending = false;
           if (batchDepth === 0) {
             notifyChange();
-          }
+          } else {}
         });
       }
+    } else {
+      pendingChange = pendingChange || { paths: [], newValues: {} };
     }
   }
   const proxyCache = new WeakMap;
@@ -382,11 +441,12 @@ function createObservableState(initialState, options) {
         return true;
       },
       deleteProperty(obj, prop) {
-        if (prop in obj) {
-          delete obj[prop];
+        const existed = Object.prototype.hasOwnProperty.call(obj, prop);
+        const result = delete obj[prop];
+        if (existed) {
           scheduleBatch();
         }
-        return true;
+        return result;
       }
     });
     proxyCache.set(target, proxy);
@@ -650,6 +710,7 @@ class HypenAppBuilder {
   errorHandler;
   template;
   _registry;
+  dataSourceEntries = [];
   constructor(initialState, options, registry) {
     this.initialState = initialState;
     this.options = options || {};
@@ -683,10 +744,19 @@ class HypenAppBuilder {
     this.errorHandler = fn;
     return this;
   }
+  useDataSource(plugin, config2) {
+    this.dataSourceEntries.push({ plugin, config: config2 });
+    return this;
+  }
   ui(template) {
     this.template = template;
     return this.build();
   }
+  uiFile(path) {
+    const fs = __require("fs");
+    this.template = fs.readFileSync(path, "utf-8").trim();
+    return this.build();
+  }
   build() {
     const stateKeys = this.initialState !== null && typeof this.initialState === "object" ? Object.keys(this.initialState) : [];
     const definition = {
@@ -697,6 +767,7 @@ class HypenAppBuilder {
       version: this.options.version,
       initialState: this.initialState,
       template: this.template,
+      dataSources: this.dataSourceEntries.length > 0 ? this.dataSourceEntries : undefined,
       handlers: {
         onCreated: this.createdHandler,
         onAction: this.actionHandlers,
@@ -758,6 +829,8 @@ class HypenModuleInstance {
   router;
   globalContext;
   stateChangeCallbacks = [];
+  dataSourceManager;
+  dataSourceAccessor = {};
   constructor(engine, definition, router, globalContext) {
     this.engine = engine;
     this.definition = definition;
@@ -787,7 +860,8 @@ class HypenModuleInstance {
         const result = await this.executeAction(actionName, handler, {
           action: actionCtx,
           state: this.state,
-          context
+          context,
+          dataSources: this.dataSourceAccessor
         });
         if (!result.ok) {
           const shouldRethrow = await this.handleError(result.error, { actionName });
@@ -830,8 +904,9 @@ class HypenModuleInstance {
       on: (event, handler) => ctx.on(event, handler),
       router: this.router
     };
-    if (ctx.__hypenEngine) {
-      api.__hypenEngine = ctx.__hypenEngine;
+    const ctxRecord = ctx;
+    if (ctxRecord.__hypenEngine) {
+      api.__hypenEngine = ctxRecord.__hypenEngine;
     }
     return api;
   }
@@ -878,6 +953,25 @@ class HypenModuleInstance {
     return false;
   }
   async callCreatedHandler() {
+    if (this.definition.dataSources?.length) {
+      const dsEngine = this.engine;
+      this.dataSourceManager = new DataSourceManager(dsEngine);
+      for (const { plugin, config: config2 } of this.definition.dataSources) {
+        try {
+          await this.dataSourceManager.use(plugin, config2);
+          this.dataSourceAccessor[plugin.name] = new Proxy(plugin, {
+            get(target, prop) {
+              if (typeof prop === "string" && !(prop in target)) {
+                return (...args) => target.call(prop, ...args);
+              }
+              return target[prop];
+            }
+          });
+        } catch (e) {
+          log2.error(`Failed to connect data source "${plugin.name}":`, e);
+        }
+      }
+    }
     if (this.definition.handlers.onCreated) {
       const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
       try {
@@ -897,6 +991,15 @@ class HypenModuleInstance {
   async destroy() {
     if (this.isDestroyed)
       return;
+    if (this.dataSourceManager) {
+      try {
+        await this.dataSourceManager.disconnectAll();
+      } catch (e) {
+        log2.error("Error disconnecting data sources:", e);
+      }
+      this.dataSourceManager = undefined;
+      this.dataSourceAccessor = {};
+    }
     if (this.definition.handlers.onDestroyed) {
       try {
         await this.definition.handlers.onDestroyed(this.state);
@@ -1036,14 +1139,165 @@ class ConsoleRenderer {
 }
 // src/router.ts
 init_state();
+
+// src/disposable.ts
 init_logger();
-var log4 = frameworkLoggers.router;
+var log4 = frameworkLoggers.lifecycle;
+function isDisposable(obj) {
+  return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
+}
+
+class DisposableStack {
+  stack = [];
+  disposed = false;
+  add(disposable) {
+    if (this.disposed) {
+      disposable.dispose();
+      return disposable;
+    }
+    this.stack.push(disposable);
+    return disposable;
+  }
+  addCallback(callback) {
+    this.add({ dispose: callback });
+  }
+  addValue(value, dispose) {
+    this.add({ dispose: () => dispose(value) });
+    return value;
+  }
+  dispose() {
+    if (this.disposed)
+      return;
+    this.disposed = true;
+    while (this.stack.length > 0) {
+      const item2 = this.stack.pop();
+      try {
+        item2.dispose();
+      } catch (error) {
+        log4.error("Error during dispose:", error);
+      }
+    }
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  get size() {
+    return this.stack.length;
+  }
+}
+function disposableListener(target, event, handler, options) {
+  target.addEventListener(event, handler, options);
+  return {
+    dispose: () => target.removeEventListener(event, handler, options)
+  };
+}
+function disposableTimeout(callback, ms) {
+  const id = setTimeout(callback, ms);
+  return {
+    id,
+    dispose: () => clearTimeout(id)
+  };
+}
+function disposableInterval(callback, ms) {
+  const id = setInterval(callback, ms);
+  return {
+    id,
+    dispose: () => clearInterval(id)
+  };
+}
+function disposableWebSocket(ws) {
+  return {
+    dispose: () => {
+      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+        ws.close();
+      }
+    }
+  };
+}
+function disposableAbortController() {
+  const controller = new AbortController;
+  return {
+    controller,
+    signal: controller.signal,
+    dispose: () => controller.abort()
+  };
+}
+function disposableSubscription(unsubscribe) {
+  return { dispose: unsubscribe };
+}
+var ELEMENT_DISPOSABLES = Symbol("hypen.disposables");
+function getElementDisposables(element) {
+  const existing = element[ELEMENT_DISPOSABLES];
+  if (existing instanceof DisposableStack) {
+    return existing;
+  }
+  const stack = new DisposableStack;
+  element[ELEMENT_DISPOSABLES] = stack;
+  return stack;
+}
+function disposeElement(element) {
+  const stack = element[ELEMENT_DISPOSABLES];
+  if (stack instanceof DisposableStack) {
+    stack.dispose();
+    delete element[ELEMENT_DISPOSABLES];
+  }
+}
+function hasElementDisposables(element) {
+  return element[ELEMENT_DISPOSABLES] instanceof DisposableStack;
+}
+
+class DisposableMixin {
+  disposables = new DisposableStack;
+  track(disposable) {
+    return this.disposables.add(disposable);
+  }
+  onDispose(callback) {
+    this.disposables.addCallback(callback);
+  }
+  dispose() {
+    this.disposables.dispose();
+  }
+}
+function compositeDisposable(...disposables) {
+  return {
+    dispose: () => {
+      for (const d of disposables) {
+        try {
+          d.dispose();
+        } catch (error) {
+          log4.error("Error during dispose:", error);
+        }
+      }
+    }
+  };
+}
+async function using(resource, fn) {
+  const r = typeof resource === "function" ? resource() : resource;
+  try {
+    return await fn(r);
+  } finally {
+    r.dispose();
+  }
+}
+function usingSync(resource, fn) {
+  const r = typeof resource === "function" ? resource() : resource;
+  try {
+    return fn(r);
+  } finally {
+    r.dispose();
+  }
+}
+
+// src/router.ts
+init_logger();
+var log5 = frameworkLoggers.router;
 
 class HypenRouter {
   state;
   subscribers = new Set;
   isInitialized = false;
   isUpdating = false;
+  browserListeners = [];
   constructor() {
     this.state = createObservableState({
       currentPath: "/",
@@ -1064,18 +1318,18 @@ class HypenRouter {
     this.state.currentPath = initialPath;
     this.state.params = {};
     this.state.query = this.parseQuery();
-    window.addEventListener("popstate", () => {
+    this.browserListeners.push(disposableListener(window, "popstate", () => {
       const newPath = this.getPathFromBrowser();
       this.updatePath(newPath, false);
-    });
-    window.addEventListener("hashchange", () => {
+    }));
+    this.browserListeners.push(disposableListener(window, "hashchange", () => {
       if (this.isUpdating)
         return;
       const newPath = this.getPathFromBrowser();
       this.updatePath(newPath, false);
-    });
+    }));
     this.isInitialized = true;
-    log4.debug("Router initialized at:", initialPath);
+    log5.debug("Router initialized at:", initialPath);
   }
   getPathFromBrowser() {
     if (typeof window === "undefined")
@@ -1096,21 +1350,21 @@ class HypenRouter {
     return query;
   }
   push(path) {
-    log4.debug("push:", path);
+    log5.debug("push:", path);
     this.updatePath(path, true);
   }
   replace(path) {
-    log4.debug("replace:", path);
+    log5.debug("replace:", path);
     this.updatePath(path, true, true);
   }
   back() {
-    log4.debug("back");
+    log5.debug("back");
     if (typeof window !== "undefined") {
       window.history.back();
     }
   }
   forward() {
-    log4.debug("forward");
+    log5.debug("forward");
     if (typeof window !== "undefined") {
       window.history.forward();
     }
@@ -1206,7 +1460,7 @@ class HypenRouter {
     try {
       callback(this.getState());
     } catch (error) {
-      log4.error("Error in route subscriber:", error);
+      log5.error("Error in route subscriber:", error);
     }
     return () => {
       this.subscribers.delete(callback);
@@ -1218,7 +1472,7 @@ class HypenRouter {
       try {
         callback(routeState);
       } catch (error) {
-        log4.error("Error in route subscriber:", error);
+        log5.error("Error in route subscriber:", error);
       }
     });
   }
@@ -1232,10 +1486,22 @@ class HypenRouter {
     const queryString = new URLSearchParams(query).toString();
     return `${path}?${queryString}`;
   }
+  dispose() {
+    for (const listener of this.browserListeners) {
+      listener.dispose();
+    }
+    this.browserListeners = [];
+    this.subscribers.clear();
+    this.isInitialized = false;
+    log5.debug("Router disposed");
+  }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
 }
 // src/events.ts
 init_logger();
-var log5 = frameworkLoggers.events;
+var log6 = frameworkLoggers.events;
 
 class TypedEventEmitter {
   eventBus = new Map;
@@ -1248,7 +1514,7 @@ class TypedEventEmitter {
       try {
         handler(payload);
       } catch (error) {
-        log5.error(`Error in event handler for "${String(event)}":`, error);
+        log6.error(`Error in event handler for "${String(event)}":`, error);
       }
     });
   }
@@ -1300,7 +1566,7 @@ function createEventEmitter() {
 }
 // src/context.ts
 init_logger();
-var log6 = frameworkLoggers.context;
+var log7 = frameworkLoggers.context;
 
 class HypenGlobalContext {
   modules = new Map;
@@ -1314,14 +1580,14 @@ class HypenGlobalContext {
   }
   registerModule(id, instance) {
     if (this.modules.has(id)) {
-      log6.warn(`Module "${id}" is already registered. Overwriting.`);
+      log7.warn(`Module "${id}" is already registered. Overwriting.`);
     }
     this.modules.set(id, instance);
-    log6.debug(`Registered module: ${id}`);
+    log7.debug(`Registered module: ${id}`);
   }
   unregisterModule(id) {
     this.modules.delete(id);
-    log6.debug(`Unregistered module: ${id}`);
+    log7.debug(`Unregistered module: ${id}`);
   }
   getModule(id) {
     const module = this.modules.get(id);
@@ -1350,14 +1616,14 @@ class HypenGlobalContext {
   emit(event, payload) {
     const handlers = this.legacyEventBus.get(event);
     if (!handlers || handlers.size === 0) {
-      log6.debug(`Event "${event}" emitted but no listeners`);
+      log7.debug(`Event "${event}" emitted but no listeners`);
     } else {
-      log6.debug(`Emitting event: ${event}`, payload);
+      log7.debug(`Emitting event: ${event}`, payload);
       handlers.forEach((handler) => {
         try {
           handler(payload);
         } catch (error) {
-          log6.error(`Error in event handler for "${event}":`, error);
+          log7.error(`Error in event handler for "${event}":`, error);
         }
       });
     }
@@ -1371,7 +1637,7 @@ class HypenGlobalContext {
     }
     const handlers = this.legacyEventBus.get(event);
     handlers.add(handler);
-    log6.debug(`Listening to event: ${event}`);
+    log7.debug(`Listening to event: ${event}`);
     return () => {
       handlers.delete(handler);
       if (handlers.size === 0) {
@@ -1406,154 +1672,6 @@ class HypenGlobalContext {
 // src/remote/client.ts
 init_result();
 
-// src/disposable.ts
-init_logger();
-var log7 = frameworkLoggers.lifecycle;
-function isDisposable(obj) {
-  return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
-}
-
-class DisposableStack {
-  stack = [];
-  disposed = false;
-  add(disposable) {
-    if (this.disposed) {
-      disposable.dispose();
-      return disposable;
-    }
-    this.stack.push(disposable);
-    return disposable;
-  }
-  addCallback(callback) {
-    this.add({ dispose: callback });
-  }
-  addValue(value, dispose) {
-    this.add({ dispose: () => dispose(value) });
-    return value;
-  }
-  dispose() {
-    if (this.disposed)
-      return;
-    this.disposed = true;
-    while (this.stack.length > 0) {
-      const item2 = this.stack.pop();
-      try {
-        item2.dispose();
-      } catch (error) {
-        log7.error("Error during dispose:", error);
-      }
-    }
-  }
-  get isDisposed() {
-    return this.disposed;
-  }
-  get size() {
-    return this.stack.length;
-  }
-}
-function disposableListener(target, event, handler, options) {
-  target.addEventListener(event, handler, options);
-  return {
-    dispose: () => target.removeEventListener(event, handler, options)
-  };
-}
-function disposableTimeout(callback, ms) {
-  const id = setTimeout(callback, ms);
-  return {
-    id,
-    dispose: () => clearTimeout(id)
-  };
-}
-function disposableInterval(callback, ms) {
-  const id = setInterval(callback, ms);
-  return {
-    id,
-    dispose: () => clearInterval(id)
-  };
-}
-function disposableWebSocket(ws) {
-  return {
-    dispose: () => {
-      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
-        ws.close();
-      }
-    }
-  };
-}
-function disposableAbortController() {
-  const controller = new AbortController;
-  return {
-    controller,
-    signal: controller.signal,
-    dispose: () => controller.abort()
-  };
-}
-function disposableSubscription(unsubscribe) {
-  return { dispose: unsubscribe };
-}
-var ELEMENT_DISPOSABLES = Symbol("hypen.disposables");
-function getElementDisposables(element) {
-  const existing = element[ELEMENT_DISPOSABLES];
-  if (existing instanceof DisposableStack) {
-    return existing;
-  }
-  const stack = new DisposableStack;
-  element[ELEMENT_DISPOSABLES] = stack;
-  return stack;
-}
-function disposeElement(element) {
-  const stack = element[ELEMENT_DISPOSABLES];
-  if (stack instanceof DisposableStack) {
-    stack.dispose();
-    delete element[ELEMENT_DISPOSABLES];
-  }
-}
-function hasElementDisposables(element) {
-  return element[ELEMENT_DISPOSABLES] instanceof DisposableStack;
-}
-
-class DisposableMixin {
-  disposables = new DisposableStack;
-  track(disposable) {
-    return this.disposables.add(disposable);
-  }
-  onDispose(callback) {
-    this.disposables.addCallback(callback);
-  }
-  dispose() {
-    this.disposables.dispose();
-  }
-}
-function compositeDisposable(...disposables) {
-  return {
-    dispose: () => {
-      for (const d of disposables) {
-        try {
-          d.dispose();
-        } catch (error) {
-          log7.error("Error during dispose:", error);
-        }
-      }
-    }
-  };
-}
-async function using(resource, fn) {
-  const r = typeof resource === "function" ? resource() : resource;
-  try {
-    return await fn(r);
-  } finally {
-    r.dispose();
-  }
-}
-function usingSync(resource, fn) {
-  const r = typeof resource === "function" ? resource() : resource;
-  try {
-    return fn(r);
-  } finally {
-    r.dispose();
-  }
-}
-
 // src/retry.ts
 init_result();
 var DEFAULT_OPTIONS = {
@@ -2345,6 +2463,7 @@ export {
   Err,
   DisposableStack,
   DisposableMixin,
+  DataSourceManager,
   ConsoleRenderer,
   ConnectionError,
   ComponentResolver,
@@ -2352,4 +2471,4 @@ export {
   ActionError
 };
 
-//# debugId=3A4A103012E4551664756E2164756E21
+//# debugId=D4B51C3A115B4AA664756E2164756E21