@hypen-space/core 0.4.3 → 0.4.5

package/dist/remote/server.js

@@ -361,7 +361,20 @@ function all(results) {
   }
   return Ok(values);
 }
-var HypenError, ActionError, ConnectionError, StateError;
+function classifyEngineError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.startsWith("Parse error:")) {
+    return new ParseError(message);
+  }
+  if (message.startsWith("Invalid state:") || message.startsWith("Invalid state patch:")) {
+    return new StateError(message);
+  }
+  if (message.startsWith("Parent node not found:")) {
+    return new RenderError(message);
+  }
+  return new RenderError(message);
+}
+var HypenError, ActionError, ConnectionError, StateError, ParseError, RenderError;
 var init_result = __esm(() => {
   HypenError = class HypenError extends Error {
     code;
@@ -411,6 +424,25 @@ var init_result = __esm(() => {
       this.path = path;
     }
   };
+  ParseError = class ParseError extends HypenError {
+    source;
+    constructor(message, source, cause) {
+      super("PARSE_ERROR", message, {
+        context: { source },
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "ParseError";
+      this.source = source;
+    }
+  };
+  RenderError = class RenderError extends HypenError {
+    constructor(message, cause) {
+      super("RENDER_ERROR", message, {
+        cause: cause instanceof Error ? cause : undefined
+      });
+      this.name = "RenderError";
+    }
+  };
 });
 
 // src/logger.ts
@@ -632,9 +664,11 @@ class HypenAppBuilder {
   expireHandler;
   errorHandler;
   template;
-  constructor(initialState, options) {
+  _registry;
+  constructor(initialState, options, registry) {
     this.initialState = initialState;
     this.options = options || {};
+    this._registry = registry;
   }
   onCreated(fn) {
     this.createdHandler = fn;
@@ -670,7 +704,7 @@ class HypenAppBuilder {
   }
   build() {
     const stateKeys = this.initialState !== null && typeof this.initialState === "object" ? Object.keys(this.initialState) : [];
-    return {
+    const definition = {
       name: this.options.name,
       actions: Array.from(this.actionHandlers.keys()),
       stateKeys,
@@ -688,12 +722,46 @@ class HypenAppBuilder {
         onError: this.errorHandler
       }
     };
+    if (this.options.name && this._registry) {
+      this._registry.set(this.options.name, definition);
+    }
+    return definition;
   }
 }
 
 class HypenApp {
+  _registry = new Map;
   defineState(initial, options) {
-    return new HypenAppBuilder(initial, options);
+    return new HypenAppBuilder(initial, options, this._registry);
+  }
+  module(name) {
+    const registry = this._registry;
+    return {
+      defineState: (initial, options) => {
+        return new HypenAppBuilder(initial, { ...options, name }, registry);
+      }
+    };
+  }
+  get(name) {
+    return this._registry.get(name);
+  }
+  has(name) {
+    return this._registry.has(name);
+  }
+  get components() {
+    return this._registry;
+  }
+  getNames() {
+    return Array.from(this._registry.keys());
+  }
+  get size() {
+    return this._registry.size;
+  }
+  unregister(name) {
+    this._registry.delete(name);
+  }
+  clear() {
+    this._registry.clear();
   }
 }
 
@@ -702,13 +770,13 @@ class HypenModuleInstance {
   definition;
   state;
   isDestroyed = false;
-  routerContext;
+  router;
   globalContext;
   stateChangeCallbacks = [];
-  constructor(engine, definition, routerContext, globalContext) {
+  constructor(engine, definition, router, globalContext) {
     this.engine = engine;
     this.definition = definition;
-    this.routerContext = routerContext;
+    this.router = router ?? null;
     this.globalContext = globalContext;
     const statePrefix = (definition.name || "").toLowerCase();
     this.state = createObservableState(definition.initialState, {
@@ -730,14 +798,10 @@ class HypenModuleInstance {
           payload: action.payload,
           sender: action.sender
         };
-        const next = {
-          router: this.routerContext?.root || null
-        };
         const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
         const result = await this.executeAction(actionName, handler, {
           action: actionCtx,
           state: this.state,
-          next,
           context
         });
         if (!result.ok) {
@@ -750,6 +814,21 @@ class HypenModuleInstance {
         }
       });
     }
+    this.engine.onAction("__hypen_bind", (action) => {
+      const payload = action.payload;
+      if (!payload?.path)
+        return;
+      const segments = payload.path.split(".");
+      let target = this.state;
+      for (let i = 0;i < segments.length - 1; i++) {
+        const seg = segments[i];
+        target = target?.[seg];
+        if (target == null)
+          return;
+      }
+      const lastSeg = segments[segments.length - 1];
+      target[lastSeg] = payload.value;
+    });
     this.callCreatedHandler();
   }
   createGlobalContextAPI() {
@@ -763,11 +842,9 @@ class HypenModuleInstance {
       getModuleIds: () => ctx.getModuleIds(),
       getGlobalState: () => ctx.getGlobalState(),
       emit: (event, payload) => ctx.emit(event, payload),
-      on: (event, handler) => ctx.on(event, handler)
+      on: (event, handler) => ctx.on(event, handler),
+      router: this.router
     };
-    if (ctx.__router) {
-      api.__router = ctx.__router;
-    }
     if (ctx.__hypenEngine) {
       api.__hypenEngine = ctx.__hypenEngine;
     }
@@ -818,7 +895,15 @@ class HypenModuleInstance {
   async callCreatedHandler() {
     if (this.definition.handlers.onCreated) {
       const context = this.globalContext ? this.createGlobalContextAPI() : undefined;
-      await this.definition.handlers.onCreated(this.state, context);
+      try {
+        await this.definition.handlers.onCreated(this.state, context);
+      } catch (e) {
+        const error = e instanceof HypenError ? e : new ActionError("onCreated", e);
+        const shouldRethrow = await this.handleError(error, { lifecycle: "created" });
+        if (shouldRethrow) {
+          throw error;
+        }
+      }
     }
   }
   onStateChange(callback) {
@@ -828,7 +913,15 @@ class HypenModuleInstance {
     if (this.isDestroyed)
       return;
     if (this.definition.handlers.onDestroyed) {
-      await this.definition.handlers.onDestroyed(this.state);
+      try {
+        await this.definition.handlers.onDestroyed(this.state);
+      } catch (e) {
+        const error = e instanceof HypenError ? e : new ActionError("onDestroyed", e);
+        const shouldRethrow = await this.handleError(error, { lifecycle: "destroyed" });
+        if (shouldRethrow) {
+          throw error;
+        }
+      }
     }
     this.isDestroyed = true;
   }
@@ -853,6 +946,7 @@ var init_app = __esm(() => {
 
 // src/engine.ts
 init_logger();
+init_result();
 import { WasmEngine } from "../wasm-node/hypen_engine.js";
 var log3 = frameworkLoggers.engine;
 function unwrapForWasm(value) {
@@ -899,7 +993,11 @@ class Engine {
   }
   renderSource(source) {
     const engine = this.ensureInitialized();
-    engine.renderSource(source);
+    try {
+      engine.renderSource(source);
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
   }
   renderLazyComponent(source) {
     const engine = this.ensureInitialized();
@@ -907,14 +1005,22 @@ class Engine {
   }
   renderInto(source, parentNodeId, state) {
     const engine = this.ensureInitialized();
-    engine.renderInto(source, parentNodeId, unwrapForWasm(state));
+    try {
+      engine.renderInto(source, parentNodeId, unwrapForWasm(state));
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
   }
   notifyStateChange(paths, values) {
     const engine = this.ensureInitialized();
     if (paths.length === 0) {
       return;
     }
-    engine.updateStateSparse(paths, unwrapForWasm(values));
+    try {
+      engine.updateStateSparse(paths, unwrapForWasm(values));
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
     log3.debug("State changed (sparse):", paths);
   }
   notifyStateChangeFull(paths, currentState) {
@@ -930,7 +1036,11 @@ class Engine {
   }
   dispatchAction(name, payload) {
     const engine = this.ensureInitialized();
-    engine.dispatchAction(name, payload ?? null);
+    try {
+      engine.dispatchAction(name, payload ?? null);
+    } catch (err) {
+      throw classifyEngineError(err);
+    }
   }
   onAction(actionName, handler) {
     const engine = this.ensureInitialized();
@@ -956,6 +1066,297 @@ class Engine {
   }
 }
 
+// src/discovery.ts
+init_logger();
+import { existsSync, readdirSync, readFileSync, watch } from "fs";
+import { join, basename, resolve, relative } from "path";
+async function discoverComponents(baseDir, options = {}) {
+  const {
+    patterns = ["single-file", "folder", "sibling", "index"],
+    recursive = true,
+    debug = false
+  } = options;
+  const log4 = debug ? (...args) => frameworkLoggers.discovery.debug(...args) : () => {};
+  const resolvedDir = resolve(baseDir);
+  const components = [];
+  const seen = new Set;
+  log4("Scanning directory:", resolvedDir);
+  log4("Patterns:", patterns);
+  const addTwoFileComponent = (name, hypenPath, modulePath) => {
+    if (seen.has(name)) {
+      log4(`Skipping duplicate: ${name}`);
+      return;
+    }
+    seen.add(name);
+    const templateRaw = readFileSync(hypenPath, "utf-8");
+    const template = templateRaw.trim();
+    components.push({
+      name,
+      hypenPath,
+      modulePath,
+      template,
+      hasModule: modulePath !== null,
+      isSingleFile: false
+    });
+    log4(`Found: ${name} (two-file, ${modulePath ? "with module" : "stateless"})`);
+  };
+  const addSingleFileComponent = (name, modulePath, template) => {
+    if (seen.has(name)) {
+      log4(`Skipping duplicate: ${name}`);
+      return;
+    }
+    seen.add(name);
+    components.push({
+      name,
+      hypenPath: null,
+      modulePath,
+      template,
+      hasModule: true,
+      isSingleFile: true
+    });
+    log4(`Found: ${name} (single-file with inline template)`);
+  };
+  const scanForFolderComponents = (dir) => {
+    if (!existsSync(dir))
+      return;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const folderPath = join(dir, entry.name);
+      const componentName = entry.name;
+      if (patterns.includes("folder")) {
+        const hypenPath = join(folderPath, "component.hypen");
+        if (existsSync(hypenPath)) {
+          const modulePath = join(folderPath, "component.ts");
+          addTwoFileComponent(componentName, hypenPath, existsSync(modulePath) ? modulePath : null);
+          continue;
+        }
+      }
+      if (patterns.includes("index")) {
+        const hypenPath = join(folderPath, "index.hypen");
+        if (existsSync(hypenPath)) {
+          const modulePath = join(folderPath, "index.ts");
+          addTwoFileComponent(componentName, hypenPath, existsSync(modulePath) ? modulePath : null);
+          continue;
+        }
+      }
+      if (recursive) {
+        scanForFolderComponents(folderPath);
+      }
+    }
+  };
+  const scanForSiblingComponents = (dir) => {
+    if (!existsSync(dir))
+      return;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (recursive) {
+          scanForSiblingComponents(join(dir, entry.name));
+        }
+        continue;
+      }
+      if (!entry.name.endsWith(".hypen"))
+        continue;
+      const hypenPath = join(dir, entry.name);
+      const baseName = basename(entry.name, ".hypen");
+      if (baseName === "component" || baseName === "index")
+        continue;
+      const modulePath = join(dir, `${baseName}.ts`);
+      addTwoFileComponent(baseName, hypenPath, existsSync(modulePath) ? modulePath : null);
+    }
+  };
+  const scanForSingleFileComponents = async (dir) => {
+    if (!existsSync(dir))
+      return;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (recursive) {
+          await scanForSingleFileComponents(join(dir, entry.name));
+        }
+        continue;
+      }
+      if (!entry.name.endsWith(".ts"))
+        continue;
+      if (entry.name.startsWith(".") || entry.name.includes(".test.") || entry.name.includes(".spec."))
+        continue;
+      const baseName = basename(entry.name, ".ts");
+      if (baseName === "component" || baseName === "index")
+        continue;
+      const hypenPath = join(dir, `${baseName}.hypen`);
+      if (existsSync(hypenPath))
+        continue;
+      const modulePath = join(dir, entry.name);
+      const content = readFileSync(modulePath, "utf-8");
+      if (content.includes(".ui(") || content.includes(".ui(hypen")) {
+        try {
+          const moduleExport = await import(modulePath);
+          const module = moduleExport.default;
+          if (module && typeof module === "object" && module.template) {
+            addSingleFileComponent(baseName, modulePath, module.template);
+          }
+        } catch (e) {
+          log4(`Failed to import potential single-file component: ${entry.name}`, e);
+        }
+      }
+    }
+  };
+  if (patterns.includes("folder") || patterns.includes("index")) {
+    scanForFolderComponents(resolvedDir);
+  }
+  if (patterns.includes("sibling")) {
+    scanForSiblingComponents(resolvedDir);
+  }
+  if (patterns.includes("single-file")) {
+    await scanForSingleFileComponents(resolvedDir);
+  }
+  log4(`Discovered ${components.length} components`);
+  return components;
+}
+async function loadDiscoveredComponents(components) {
+  const { app: app2 } = await Promise.resolve().then(() => (init_app(), exports_app));
+  const loaded = new Map;
+  for (const component of components) {
+    let module;
+    let template = component.template;
+    if (component.modulePath) {
+      const moduleExport = await import(component.modulePath);
+      module = moduleExport.default;
+      if (component.isSingleFile && module.template) {
+        template = module.template;
+      }
+    } else {
+      module = app2.defineState({}).build();
+    }
+    loaded.set(component.name, {
+      name: component.name,
+      module,
+      template
+    });
+  }
+  return loaded;
+}
+function watchComponents(baseDir, options = {}) {
+  const resolvedDir = resolve(baseDir);
+  const {
+    onChange,
+    onAdd,
+    onRemove,
+    onUpdate,
+    debug = false,
+    ...discoveryOptions
+  } = options;
+  const log4 = debug ? (...args) => frameworkLoggers.discovery.debug("[watch]", ...args) : () => {};
+  let currentComponents = new Map;
+  let debounceTimer = null;
+  const initialScan = async () => {
+    const components = await discoverComponents(resolvedDir, discoveryOptions);
+    currentComponents = new Map(components.map((c) => [c.name, c]));
+    onChange?.(components);
+  };
+  const rescan = async () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(async () => {
+      log4("Rescanning...");
+      const newComponents = await discoverComponents(resolvedDir, discoveryOptions);
+      const newMap = new Map(newComponents.map((c) => [c.name, c]));
+      for (const [name, component] of newMap) {
+        const existing = currentComponents.get(name);
+        if (!existing) {
+          log4("Added:", name);
+          onAdd?.(component);
+        } else if (existing.template !== component.template || existing.modulePath !== component.modulePath) {
+          log4("Updated:", name);
+          onUpdate?.(component);
+        }
+      }
+      for (const name of currentComponents.keys()) {
+        if (!newMap.has(name)) {
+          log4("Removed:", name);
+          onRemove?.(name);
+        }
+      }
+      currentComponents = newMap;
+      onChange?.(newComponents);
+    }, 100);
+  };
+  const watcher = watch(resolvedDir, { recursive: true }, (event, filename) => {
+    if (!filename)
+      return;
+    if (filename.endsWith(".hypen") || filename.endsWith(".ts")) {
+      log4("File changed:", filename);
+      rescan();
+    }
+  });
+  initialScan();
+  return {
+    stop: () => {
+      watcher.close();
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+    }
+  };
+}
+async function generateComponentsCode(baseDir, options = {}) {
+  const components = await discoverComponents(baseDir, options);
+  const resolvedDir = resolve(baseDir);
+  const outputBase = options.outputDir ? resolve(options.outputDir) : resolvedDir;
+  let code = `/**
+ * Auto-generated component imports
+ * Generated by @hypen-space/core discovery
+ */
+
+`;
+  for (const component of components) {
+    let importPath = null;
+    if (component.modulePath) {
+      const rel = relative(outputBase, component.modulePath).replace(/\.ts$/, ".js");
+      importPath = rel.startsWith(".") ? rel : "./" + rel;
+    }
+    if (importPath) {
+      code += `import ${component.name}Module from "${importPath}";
+`;
+    }
+  }
+  code += `
+import { app } from "@hypen-space/core";
+
+`;
+  for (const component of components) {
+    if (component.isSingleFile) {
+      code += `export const ${component.name} = {
+  module: ${component.name}Module,
+  template: ${component.name}Module.template,
+};
+
+`;
+    } else if (component.hasModule) {
+      const templateJson = JSON.stringify(component.template);
+      code += `export const ${component.name} = {
+  module: ${component.name}Module,
+  template: ${templateJson},
+};
+
+`;
+    } else {
+      const templateJson = JSON.stringify(component.template);
+      code += `const ${component.name}Module = app.defineState({}).build();
+export const ${component.name} = {
+  module: ${component.name}Module,
+  template: ${templateJson},
+};
+
+`;
+    }
+  }
+  return code;
+}
+
 // src/remote/server.ts
 init_app();
 
@@ -1091,6 +1492,8 @@ class RemoteServer {
   _module = null;
   _moduleName = "App";
   _ui = "";
+  _sourceDir = null;
+  _discoveredComponents = new Map;
   _config = {};
   _sessionConfig = {};
   _onConnectionCallbacks = [];
@@ -1108,6 +1511,10 @@ class RemoteServer {
     this._ui = dsl;
     return this;
   }
+  source(dir) {
+    this._sourceDir = dir;
+    return this;
+  }
   config(config2) {
     this._config = { ...this._config, ...config2 };
     return this;
@@ -1124,12 +1531,15 @@ class RemoteServer {
     this._onDisconnectionCallbacks.push(callback);
     return this;
   }
-  listen(port) {
+  async listen(port) {
     if (!this._module) {
       throw new Error("Module not set. Call .module() before .listen()");
     }
+    if (this._sourceDir) {
+      await this.discoverFromSource();
+    }
     if (!this._ui) {
-      throw new Error("UI not set. Call .ui() before .listen()");
+      throw new Error("UI not set. Call .ui() or .source() before .listen()");
     }
     this.sessionManager = new SessionManager(this._sessionConfig);
     const finalPort = port ?? this._config.port ?? 3000;
@@ -1183,12 +1593,42 @@ class RemoteServer {
     const port = this._config.port ?? 3000;
     return `ws://${hostname}:${port}`;
   }
+  async discoverFromSource() {
+    const dir = this._sourceDir;
+    log4.info(`Discovering components from ${dir}...`);
+    const discovered = await discoverComponents(dir);
+    const loaded = await loadDiscoveredComponents(discovered);
+    for (const [name, { module, template }] of loaded) {
+      this._discoveredComponents.set(name, { template, module });
+    }
+    log4.info(`Discovered ${this._discoveredComponents.size} components: ${Array.from(this._discoveredComponents.keys()).join(", ")}`);
+    if (!this._ui) {
+      const entry = this._discoveredComponents.get(this._moduleName);
+      if (entry) {
+        this._ui = entry.template;
+      }
+    }
+  }
+  setupComponentResolver(engine) {
+    if (this._discoveredComponents.size === 0)
+      return;
+    engine.setComponentResolver((componentName, _contextPath) => {
+      const comp = this._discoveredComponents.get(componentName);
+      if (!comp)
+        return null;
+      return {
+        source: comp.template,
+        path: componentName
+      };
+    });
+  }
   async handleOpen(ws) {
     try {
       const clientId = `client_${this.nextClientId++}`;
       const connectedAt = new Date;
       const engine = new Engine;
       await engine.init();
+      this.setupComponentResolver(engine);
       const moduleInstance = new HypenModuleInstance(engine, this._module);
       const clientData = {
         id: clientId,
@@ -1436,8 +1876,14 @@ class RemoteServer {
     });
   }
 }
-function serve(options) {
-  const server = new RemoteServer().module(options.moduleName ?? "App", options.module).ui(options.ui);
+async function serve(options) {
+  const server = new RemoteServer().module(options.moduleName ?? "App", options.module);
+  if (options.source) {
+    server.source(options.source);
+  }
+  if (options.ui) {
+    server.ui(options.ui);
+  }
   if (options.port || options.hostname) {
     server.config({
       port: options.port,
@@ -1460,4 +1906,4 @@ export {
   RemoteServer
 };
 
-//# debugId=1E9F674E53CBE95764756E2164756E21
+//# debugId=A4EC0E36B723B34E64756E2164756E21