@hypen-space/core 0.4.32 → 0.4.35

package/dist/remote/server.js

@@ -1,11 +1,15 @@
 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);
@@ -156,9 +160,11 @@ function createObservableState(initialState, options) {
           notificationPending = false;
           if (batchDepth === 0) {
             notifyChange();
-          }
+          } else {}
         });
       }
+    } else {
+      pendingChange = pendingChange || { paths: [], newValues: {} };
     }
   }
   const proxyCache = new WeakMap;
@@ -217,11 +223,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);
@@ -555,6 +562,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, config2) {
+    const { name } = plugin;
+    this.state.set(name, {});
+    this.plugins.set(name, plugin);
+    this.configs.set(name, config2);
+    await plugin.connect(config2, (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/app.ts
 var exports_app = {};
 __export(exports_app, {
@@ -576,6 +636,7 @@ class HypenAppBuilder {
   errorHandler;
   template;
   _registry;
+  dataSourceEntries = [];
   constructor(initialState, options, registry) {
     this.initialState = initialState;
     this.options = options || {};
@@ -609,10 +670,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 = (() => ({}));
+    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 = {
@@ -623,6 +693,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,
@@ -684,6 +755,8 @@ class HypenModuleInstance {
   router;
   globalContext;
   stateChangeCallbacks = [];
+  dataSourceManager;
+  dataSourceAccessor = {};
   constructor(engine, definition, router, globalContext) {
     this.engine = engine;
     this.definition = definition;
@@ -713,7 +786,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 });
@@ -756,8 +830,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;
   }
@@ -804,6 +879,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 {
@@ -823,6 +917,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);
@@ -1293,10 +1396,27 @@ class Engine {
       throw classifyEngineError(err);
     }
   }
+  _onErrorHandler;
+  setOnError(handler) {
+    this._onErrorHandler = handler;
+  }
   onAction(actionName, handler) {
     const engine = this.ensureInitialized();
+    const handleError = (err) => {
+      log3.error("Action handler error:", err);
+      if (this._onErrorHandler) {
+        this._onErrorHandler(err instanceof Error ? err : new Error(String(err)));
+      }
+    };
     engine.onAction(actionName, (action) => {
-      Promise.resolve(handler(action)).catch((err) => log3.error("Action handler error:", err));
+      try {
+        const result = handler(action);
+        if (result && typeof result.catch === "function") {
+          result.catch(handleError);
+        }
+      } catch (err) {
+        handleError(err);
+      }
     });
   }
   setModule(name, actions, stateKeys, initialState) {
@@ -1315,6 +1435,19 @@ class Engine {
     const engine = this.ensureInitialized();
     return engine.debugParseComponent(source);
   }
+  setContext(name, data) {
+    const engine = this.ensureInitialized();
+    try {
+      engine.setContext(name, unwrapForWasm(data));
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
+    log3.debug(`Data source "${name}" context set`);
+  }
+  removeContext(name) {
+    const engine = this.ensureInitialized();
+    engine.removeContext(name);
+  }
 }
 
 // src/remote/server.ts
@@ -1577,6 +1710,8 @@ async function discoverComponents(baseDir, options = {}) {
           const module = moduleExport.default;
           if (module && typeof module === "object" && module.template) {
             addSingleFileComponent(baseName, modulePath, module.template);
+          } else if (module && typeof module === "object") {
+            frameworkLoggers.discovery.warn(`Skipping "${entry.name}": has .ui() pattern but module has no .template property. Did you forget to call .ui(hypen\`...\`)?`);
           }
         } catch (e) {
           log4(`Failed to import potential single-file component: ${entry.name}`, e);
@@ -1754,8 +1889,10 @@ class RemoteServer {
       return;
     engine.setComponentResolver((componentName, _contextPath) => {
       const comp = this._discoveredComponents.get(componentName);
-      if (!comp)
+      if (!comp) {
+        log4.warn(`Component "${componentName}" not found. Available: ${Array.from(this._discoveredComponents.keys()).join(", ") || "(none)"}`);
         return null;
+      }
       return {
         source: comp.template,
         path: componentName
@@ -1966,6 +2103,10 @@ class RemoteServer {
       return;
     let restored = false;
     const restore = (state) => {
+      if (state === null || typeof state !== "object") {
+        log4.warn("restore() called with non-object state, ignoring:", typeof state);
+        return;
+      }
       restored = true;
       clientData.moduleInstance.updateState(state);
     };
@@ -2126,4 +2267,4 @@ export {
   RemoteServer
 };
 
-//# debugId=E039307432F8950364756E2164756E21
+//# debugId=23B2AD6EC2DA1C3B64756E2164756E21