@hypen-space/core 0.4.956 → 0.5.2

package/dist/engine-base.js

@@ -1,417 +1,38 @@
-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: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import {
+  classifyEngineError
+} from "./chunk-7222131a.js";
+import {
+  frameworkLoggers
+} from "./chunk-avchpwhf.js";
+import"./chunk-5gtx3pza.js";
 
-// 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/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;
-}
-function getLogLevel() {
-  return config.level;
-}
-function configureLogger(options) {
-  config = { ...config, ...options };
-}
-function enableLogging() {
-  config.level = "debug";
-}
-function disableLogging() {
-  config.level = "none";
-}
-function setDebugMode(enabled) {
-  config.level = enabled ? "debug" : "error";
-}
-function isDebugMode() {
-  return config.level === "debug";
-}
-function shouldLog(level) {
-  return LOG_LEVEL_ORDER[level] >= LOG_LEVEL_ORDER[config.level];
-}
-function formatTag(tag, level) {
-  const timestamp = config.timestamps ? `${new Date().toISOString()} ` : "";
-  if (config.colors && level !== "none") {
-    const color = LOG_LEVEL_COLORS[level];
-    return `${timestamp}${color}[${tag}]${RESET_COLOR}`;
-  }
-  return `${timestamp}[${tag}]`;
-}
-
-class Logger {
-  tag;
-  constructor(tag) {
-    this.tag = tag;
-  }
-  debug(...args) {
-    if (!shouldLog("debug"))
-      return;
-    if (config.handler) {
-      config.handler.debug(this.tag, ...args);
-    } else {
-      console.log(formatTag(this.tag, "debug"), ...args);
-    }
-  }
-  info(...args) {
-    if (!shouldLog("info"))
-      return;
-    if (config.handler) {
-      config.handler.info(this.tag, ...args);
-    } else {
-      console.info(formatTag(this.tag, "info"), ...args);
-    }
-  }
-  warn(...args) {
-    if (!shouldLog("warn"))
-      return;
-    if (config.handler) {
-      config.handler.warn(this.tag, ...args);
-    } else {
-      console.warn(formatTag(this.tag, "warn"), ...args);
-    }
-  }
-  error(...args) {
-    if (!shouldLog("error"))
-      return;
-    if (config.handler) {
-      config.handler.error(this.tag, ...args);
-    } else {
-      console.error(formatTag(this.tag, "error"), ...args);
+// src/engine-base.ts
+var log = frameworkLoggers.engine;
+function mapToPlainObject(value) {
+  if (value instanceof Map) {
+    const obj = {};
+    for (const [key, val] of value.entries()) {
+      obj[key] = mapToPlainObject(val);
     }
+    return obj;
   }
-  time(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
-    }
+  if (Array.isArray(value)) {
+    return value.map(mapToPlainObject);
   }
-  async timeAsync(label, fn) {
-    if (!shouldLog("debug")) {
-      return fn();
-    }
-    const start = performance.now();
-    try {
-      return await fn();
-    } finally {
-      const duration = performance.now() - start;
-      this.debug(`${label}: ${duration.toFixed(2)}ms`);
+  if (value && typeof value === "object" && value.constructor === Object) {
+    const obj = {};
+    for (const [key, val] of Object.entries(value)) {
+      obj[key] = mapToPlainObject(val);
     }
+    return obj;
   }
-  child(subTag) {
-    return new Logger(`${this.tag}:${subTag}`);
-  }
-  debugIf(condition, ...args) {
-    if (condition)
-      this.debug(...args);
-  }
-  warnIf(condition, ...args) {
-    if (condition)
-      this.warn(...args);
-  }
-  errorIf(condition, ...args) {
-    if (condition)
-      this.error(...args);
-  }
-  loggedOnce = new Set;
-  warnOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.warn(...args);
-  }
-  debugOnce(key, ...args) {
-    if (this.loggedOnce.has(key))
-      return;
-    this.loggedOnce.add(key);
-    this.debug(...args);
-  }
+  return value;
 }
-function createLogger(tag) {
-  return new Logger(tag);
-}
-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/engine-base.ts
-var log2 = frameworkLoggers.engine;
 
 class BaseEngine {
   wasmEngine = null;
   initialized = false;
+  unresolvedComponents = new Set;
   ensureInitialized() {
     if (!this.wasmEngine) {
       throw new Error("Engine not initialized. Call init() first.");
@@ -427,9 +48,19 @@ class BaseEngine {
   setComponentResolver(resolver) {
     const engine = this.ensureInitialized();
     engine.setComponentResolver((componentName, contextPath) => {
-      return resolver(componentName, contextPath);
+      const resolved = resolver(componentName, contextPath);
+      if (resolved == null) {
+        if (!this.unresolvedComponents.has(componentName)) {
+          this.unresolvedComponents.add(componentName);
+          log.warn(`Component "${componentName}" did not resolve: it is not a ` + `registered primitive and the component resolver returned null. ` + `The engine will emit an opaque Create for it and the renderer ` + `will drop it. Did you forget to register/.module(...) the ` + `component, or is its name misspelled in the template?`);
+        }
+      }
+      return resolved;
     });
   }
+  getUnresolvedComponents() {
+    return [...this.unresolvedComponents];
+  }
   renderSource(source) {
     const engine = this.ensureInitialized();
     try {
@@ -460,7 +91,7 @@ class BaseEngine {
     } catch (err) {
       throw classifyEngineError(err);
     }
-    log2.debug("State changed (sparse):", { scope, paths });
+    log.debug("State changed (sparse):", { scope, paths });
   }
   updateState(scope, statePatch) {
     const engine = this.ensureInitialized();
@@ -479,12 +110,14 @@ class BaseEngine {
     engine.onAction(actionName, (action) => {
       const normalized = this.normalizeAction(action);
       Promise.resolve(handler(normalized)).catch((err) => {
-        log2.error("Action handler error:", err);
+        log.error("Action handler error:", err);
       });
     });
   }
   normalizeAction(action) {
-    return action;
+    if (!action.payload)
+      return action;
+    return { ...action, payload: mapToPlainObject(action.payload) };
   }
   discoverRouters(source) {
     const engine = this.ensureInitialized();
@@ -552,20 +185,20 @@ class BaseEngine {
     } catch (err) {
       throw classifyEngineError(err);
     }
-    log2.debug(`Data source "${name}" context set`);
+    log.debug(`Data source "${name}" context set`);
   }
   removeContext(name) {
     const engine = this.ensureInitialized();
     engine.removeContext(name);
   }
-  registerResources(map2) {
+  registerResources(map) {
     const engine = this.ensureInitialized();
-    engine.registerResources(map2);
-    log2.debug(`Resources registered (${Object.keys(map2).length} entries)`);
+    engine.registerResources(map);
+    log.debug(`Resources registered (${Object.keys(map).length} entries)`);
   }
 }
 export {
   BaseEngine
 };
 
-//# debugId=F470DF8DA6B0624C64756E2164756E21
+//# debugId=0B860F9754DCCD3064756E2164756E21