@hypen-space/core 0.4.37 → 0.4.39

package/dist/components/builtin.js

@@ -21,7 +21,250 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/result.ts
+function Ok(value) {
+  return { ok: true, value };
+}
+function Err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok;
+}
+function isErr(result) {
+  return !result.ok;
+}
+async function fromPromise(promise, mapError) {
+  try {
+    const value = await promise;
+    return Ok(value);
+  } catch (e) {
+    if (mapError) {
+      return Err(mapError(e));
+    }
+    return Err(e);
+  }
+}
+function fromTry(fn, mapError) {
+  try {
+    return Ok(fn());
+  } catch (e) {
+    if (mapError) {
+      return Err(mapError(e));
+    }
+    return Err(e);
+  }
+}
+function map(result, fn) {
+  if (result.ok) {
+    return Ok(fn(result.value));
+  }
+  return result;
+}
+function mapErr(result, fn) {
+  if (!result.ok) {
+    return Err(fn(result.error));
+  }
+  return result;
+}
+function flatMap(result, fn) {
+  if (result.ok) {
+    return fn(result.value);
+  }
+  return result;
+}
+function unwrap(result) {
+  if (result.ok) {
+    return result.value;
+  }
+  throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+  if (result.ok) {
+    return result.value;
+  }
+  return defaultValue;
+}
+function unwrapOrElse(result, fn) {
+  if (result.ok) {
+    return result.value;
+  }
+  return fn(result.error);
+}
+function match(result, handlers) {
+  if (result.ok) {
+    return handlers.ok(result.value);
+  }
+  return handlers.err(result.error);
+}
+function all(results) {
+  const values = [];
+  for (const result of results) {
+    if (!result.ok) {
+      return result;
+    }
+    values.push(result.value);
+  }
+  return Ok(values);
+}
+
+class HypenError extends Error {
+  code;
+  context;
+  cause;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "HypenError";
+    this.code = code;
+    this.context = options?.context;
+    this.cause = options?.cause;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+class ActionError extends HypenError {
+  actionName;
+  constructor(actionName, cause) {
+    super("ACTION_ERROR", `Action handler "${actionName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      context: { actionName },
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "ActionError";
+    this.actionName = actionName;
+  }
+}
+
+class ConnectionError extends HypenError {
+  url;
+  attempt;
+  constructor(url, cause, attempt) {
+    super("CONNECTION_ERROR", `Connection to "${url}" failed${attempt ? ` (attempt ${attempt})` : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      context: { url, attempt },
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "ConnectionError";
+    this.url = url;
+    this.attempt = attempt;
+  }
+}
+
+class StateError extends HypenError {
+  path;
+  constructor(message, path, cause) {
+    super("STATE_ERROR", message, {
+      context: { path },
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "StateError";
+    this.path = path;
+  }
+}
+
+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;
+  }
+}
+
+class RenderError extends HypenError {
+  constructor(message, cause) {
+    super("RENDER_ERROR", message, {
+      cause: cause instanceof Error ? cause : undefined
+    });
+    this.name = "RenderError";
+  }
+}
+function classifyEngineError(err) {
+  if (err && typeof err === "object" && "message" in err && "type" in err) {
+    const structured = err;
+    switch (structured.type) {
+      case "parseError":
+        return new ParseError(structured.message);
+      case "stateError":
+        return new StateError(structured.message);
+      case "renderError":
+        return new RenderError(structured.message);
+      case "actionError":
+        return new HypenError("ACTION_ERROR", structured.message);
+      default:
+        return new HypenError("UNKNOWN_ERROR", structured.message);
+    }
+  }
+  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);
+}
+
+// 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
+var IS_PROXY = Symbol.for("hypen.isProxy");
+var RAW_TARGET = Symbol.for("hypen.rawTarget");
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
     return obj;
@@ -266,19 +509,33 @@ function unwrapProxy(value) {
   }
   return value;
 }
-var IS_PROXY, RAW_TARGET;
-var init_state = __esm(() => {
-  IS_PROXY = Symbol.for("hypen.isProxy");
-  RAW_TARGET = Symbol.for("hypen.rawTarget");
-});
 
 // src/logger.ts
+var LOG_LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4
+};
+var LOG_LEVEL_COLORS = {
+  debug: "\x1B[36m",
+  info: "\x1B[32m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var RESET_COLOR = "\x1B[0m";
 function isProduction() {
   if (typeof process !== "undefined" && process.env) {
     return false;
   }
   return false;
 }
+var config = {
+  level: isProduction() ? "error" : "info",
+  colors: true,
+  timestamps: false
+};
 function setLogLevel(level) {
   config.level = level;
 }
@@ -409,220 +666,49 @@ class Logger {
 function createLogger(tag) {
   return new Logger(tag);
 }
-var LOG_LEVEL_ORDER, LOG_LEVEL_COLORS, RESET_COLOR = "\x1B[0m", config, logger, log, frameworkLoggers;
-var init_logger = __esm(() => {
-  LOG_LEVEL_ORDER = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-    none: 4
-  };
-  LOG_LEVEL_COLORS = {
-    debug: "\x1B[36m",
-    info: "\x1B[32m",
-    warn: "\x1B[33m",
-    error: "\x1B[31m"
-  };
-  config = {
-    level: isProduction() ? "error" : "info",
-    colors: true,
-    timestamps: false
-  };
-  logger = createLogger("Hypen");
-  log = {
-    debug: (tag, ...args) => {
-      if (!shouldLog("debug"))
-        return;
-      console.log(formatTag(tag, "debug"), ...args);
-    },
-    info: (tag, ...args) => {
-      if (!shouldLog("info"))
-        return;
-      console.info(formatTag(tag, "info"), ...args);
-    },
-    warn: (tag, ...args) => {
-      if (!shouldLog("warn"))
-        return;
-      console.warn(formatTag(tag, "warn"), ...args);
-    },
-    error: (tag, ...args) => {
-      if (!shouldLog("error"))
-        return;
-      console.error(formatTag(tag, "error"), ...args);
-    }
-  };
-  frameworkLoggers = {
-    hypen: createLogger("Hypen"),
-    engine: createLogger("Engine"),
-    router: createLogger("Router"),
-    state: createLogger("State"),
-    events: createLogger("Events"),
-    remote: createLogger("Remote"),
-    renderer: createLogger("Renderer"),
-    module: createLogger("Module"),
-    lifecycle: createLogger("Lifecycle"),
-    loader: createLogger("Loader"),
-    context: createLogger("Context"),
-    discovery: createLogger("Discovery"),
-    plugin: createLogger("Plugin"),
-    canvas: createLogger("Canvas"),
-    debug: createLogger("Debug")
-  };
-});
-
-// src/result.ts
-function Ok(value) {
-  return { ok: true, value };
-}
-function Err(error) {
-  return { ok: false, error };
-}
-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;
-    context;
-    cause;
-    constructor(code, message, options) {
-      super(message);
-      this.name = "HypenError";
-      this.code = code;
-      this.context = options?.context;
-      this.cause = options?.cause;
-      Object.setPrototypeOf(this, new.target.prototype);
-    }
-  };
-  ActionError = class ActionError extends HypenError {
-    actionName;
-    constructor(actionName, cause) {
-      super("ACTION_ERROR", `Action handler "${actionName}" failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
-        context: { actionName },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "ActionError";
-      this.actionName = actionName;
-    }
-  };
-  ConnectionError = class ConnectionError extends HypenError {
-    url;
-    attempt;
-    constructor(url, cause, attempt) {
-      super("CONNECTION_ERROR", `Connection to "${url}" failed${attempt ? ` (attempt ${attempt})` : ""}: ${cause instanceof Error ? cause.message : String(cause)}`, {
-        context: { url, attempt },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "ConnectionError";
-      this.url = url;
-      this.attempt = attempt;
-    }
-  };
-  StateError = class StateError extends HypenError {
-    path;
-    constructor(message, path, cause) {
-      super("STATE_ERROR", message, {
-        context: { path },
-        cause: cause instanceof Error ? cause : undefined
-      });
-      this.name = "StateError";
-      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/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)));
+var logger = createLogger("Hypen");
+var log = {
+  debug: (tag, ...args) => {
+    if (!shouldLog("debug"))
+      return;
+    console.log(formatTag(tag, "debug"), ...args);
+  },
+  info: (tag, ...args) => {
+    if (!shouldLog("info"))
+      return;
+    console.info(formatTag(tag, "info"), ...args);
+  },
+  warn: (tag, ...args) => {
+    if (!shouldLog("warn"))
+      return;
+    console.warn(formatTag(tag, "warn"), ...args);
+  },
+  error: (tag, ...args) => {
+    if (!shouldLog("error"))
+      return;
+    console.error(formatTag(tag, "error"), ...args);
   }
-}
+};
+var frameworkLoggers = {
+  hypen: createLogger("Hypen"),
+  engine: createLogger("Engine"),
+  router: createLogger("Router"),
+  state: createLogger("State"),
+  events: createLogger("Events"),
+  remote: createLogger("Remote"),
+  renderer: createLogger("Renderer"),
+  module: createLogger("Module"),
+  lifecycle: createLogger("Lifecycle"),
+  loader: createLogger("Loader"),
+  context: createLogger("Context"),
+  discovery: createLogger("Discovery"),
+  plugin: createLogger("Plugin"),
+  canvas: createLogger("Canvas"),
+  debug: createLogger("Debug")
+};
 
 // src/app.ts
-var exports_app = {};
-__export(exports_app, {
-  app: () => app,
-  HypenModuleInstance: () => HypenModuleInstance,
-  HypenAppBuilder: () => HypenAppBuilder,
-  HypenApp: () => HypenApp
-});
+var log2 = createLogger("ModuleInstance");
 
 class HypenAppBuilder {
   initialState;
@@ -746,6 +832,7 @@ class HypenApp {
     this._registry.clear();
   }
 }
+var app = new HypenApp;
 
 class HypenModuleInstance {
   engine;
@@ -949,19 +1036,38 @@ class HypenModuleInstance {
     Object.assign(this.state, patch);
   }
 }
-var log2, app;
-var init_app = __esm(() => {
-  init_result();
-  init_state();
-  init_logger();
-  log2 = createLogger("ModuleInstance");
-  app = new HypenApp;
-});
 
 // src/components/builtin.ts
-init_app();
-init_logger();
 var log3 = frameworkLoggers.router;
+async function updateRouteVisibility(currentPath, engine, doc) {
+  const targetDoc = doc ?? document;
+  const routeElements = targetDoc.querySelectorAll('[data-hypen-type="route"]');
+  let matchFound = false;
+  for (let index = 0;index < routeElements.length; index++) {
+    const routeEl = routeElements[index];
+    const htmlEl = routeEl;
+    const routePath = htmlEl.dataset.routePath || "/";
+    const isMatch = routePath === currentPath;
+    htmlEl.style.display = isMatch ? "flex" : "none";
+    if (isMatch) {
+      matchFound = true;
+      const componentName = htmlEl.dataset.routeComponent;
+      const isLazy = htmlEl.dataset.routeLazy === "true";
+      const hasContent = htmlEl.children.length > 0;
+      const shouldRender = componentName && engine && (isLazy || !hasContent);
+      if (shouldRender) {
+        try {
+          await engine.renderLazyRoute(routePath, componentName, htmlEl);
+        } catch (err) {
+          log3.error(`Failed to render route ${routePath}:`, err);
+        }
+      }
+    }
+  }
+  if (!matchFound) {
+    log3.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
+  }
+}
 var Router = app.defineState({
   currentPath: "/",
   matchedRoute: null,
@@ -977,40 +1083,13 @@ var Router = app.defineState({
     return;
   }
   const hypenEngine = context.__hypenEngine;
-  const updateRouteVisibility = async (currentPath) => {
-    const routeElements = document.querySelectorAll('[data-hypen-type="route"]');
-    let matchFound = false;
-    for (let index = 0;index < routeElements.length; index++) {
-      const routeEl = routeElements[index];
-      const htmlEl = routeEl;
-      const routePath = htmlEl.dataset.routePath || "/";
-      const isMatch = routePath === currentPath;
-      htmlEl.style.display = isMatch ? "flex" : "none";
-      if (isMatch) {
-        matchFound = true;
-        const componentName = htmlEl.dataset.routeComponent;
-        const isLazy = htmlEl.dataset.routeLazy === "true";
-        const hasContent = htmlEl.children.length > 0;
-        if (componentName && !hasContent && hypenEngine) {
-          try {
-            await hypenEngine.renderLazyRoute(routePath, componentName, htmlEl);
-          } catch (err) {
-            log3.error(`Failed to render route ${routePath}:`, err);
-          }
-        }
-      }
-    }
-    if (!matchFound) {
-      log3.warn(`No route matched path: ${currentPath}. Available routes:`, Array.from(routeElements).map((el) => el.dataset.routePath));
-    }
-  };
   setTimeout(() => {
-    updateRouteVisibility(state.currentPath);
+    updateRouteVisibility(state.currentPath, hypenEngine);
   }, 100);
   router.onNavigate((routeState) => {
     state.currentPath = routeState.currentPath;
     state.routeParams = routeState.params;
-    updateRouteVisibility(routeState.currentPath);
+    updateRouteVisibility(routeState.currentPath, hypenEngine);
   });
 }).build();
 var Route = app.defineState({}, { name: "__Route" }).build();
@@ -1036,9 +1115,10 @@ var Link = app.defineState({
   }
 }).build();
 export {
+  updateRouteVisibility,
   Router,
   Route,
   Link
 };
 
-//# debugId=F6D793FE5D2E2B7E64756E2164756E21
+//# debugId=DECBF5369AD4A4FF64756E2164756E21