olova 2.0.64 → 2.0.68

package/dist/core.d.ts

@@ -1,4 +1,4 @@
-export { E as EffectCallback, a as EffectCleanup, b as EffectMode, S as Signal, c as SignalState, d as beginHmrStateCapture, e as computed, f as derived, g as effect, h as endHmrStateCapture, s as state } from './signals-core-BdfWh1Yt.js';
-export { CompiledDescriptor, DangerousHtml, OlovaComponent, OlovaProps, OlovaSlots, SetupFn, createApp, dangerouslySetHtml, defineComponent, getContext, hasContext, mount, replaceComponent, setContext } from './runtime.js';
+export { E as EffectCallback, a as EffectCleanup, R as RuntimeErrorHandler, S as Signal, b as SignalState, c as beginHmrStateCapture, d as computed, e as derived, f as effect, g as endHmrStateCapture, h as getReactiveProxyVersion, s as state, w as withRuntimeErrorHandler } from './signals-core-BWZ5zXK5.js';
+export { CompiledDescriptor, DangerousHtml, ErrorBoundaryFallback, OlovaComponent, OlovaProps, OlovaSlots, SetupFn, Suspense, createApp, createErrorBoundary, dangerouslySetHtml, defineComponent, getContext, hasContext, mount, onCleanup, onMount, replaceComponent, setContext } from './runtime.js';
 export { global } from './global.js';
 import '@preact/signals-core';

package/dist/core.js

@@ -1,10 +1,11 @@
 import { signal, effect as effect$1, computed as computed$1, untracked } from '@preact/signals-core';
 
 // core/signals-core.ts
-var rawToProxy = /* @__PURE__ */ new WeakMap();
+var rawToProxyByOwner = /* @__PURE__ */ new WeakMap();
 var proxyToRaw = /* @__PURE__ */ new WeakMap();
 var proxyOwner = /* @__PURE__ */ new WeakMap();
 var hmrCaptureStack = [];
+var runtimeErrorHandlerStack = [];
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
@@ -40,6 +41,9 @@ var Signal = class {
   notify() {
     this.version.value = this.version.peek() + 1;
   }
+  peekVersion() {
+    return this.version.peek();
+  }
   subscribe(fn) {
     return this.source.subscribe(fn);
   }
@@ -63,7 +67,8 @@ var Signal = class {
     return this.proxy;
   }
   wrapObject(value) {
-    const existing = rawToProxy.get(value);
+    const ownedProxyMap = rawToProxyByOwner.get(value);
+    const existing = ownedProxyMap?.get(this);
     if (existing) {
       return existing;
     }
@@ -90,7 +95,11 @@ var Signal = class {
         return changed;
       }
     });
-    rawToProxy.set(value, proxy);
+    const nextOwnedProxyMap = ownedProxyMap ?? /* @__PURE__ */ new WeakMap();
+    nextOwnedProxyMap.set(this, proxy);
+    if (!ownedProxyMap) {
+      rawToProxyByOwner.set(value, nextOwnedProxyMap);
+    }
     proxyToRaw.set(proxy, value);
     proxyOwner.set(proxy, this);
     return proxy;
@@ -122,15 +131,59 @@ function state(initial, hmrKey) {
   }
   return signal;
 }
-function effect(fn, options) {
-  const stop = effect$1(() => fn());
+function getReactiveProxyVersion(value) {
+  if (!isObject(value)) {
+    return null;
+  }
+  const owner = proxyOwner.get(value);
+  return owner ? owner.peekVersion() : null;
+}
+function reportRuntimeError(error, handler) {
+  if (handler) {
+    handler(error);
+    return;
+  }
+  throw error;
+}
+function withRuntimeErrorHandler(handler, fn) {
+  if (!handler) {
+    return fn();
+  }
+  runtimeErrorHandlerStack.push(handler);
+  try {
+    return fn();
+  } finally {
+    runtimeErrorHandlerStack.pop();
+  }
+}
+function effect(fn) {
+  const handler = runtimeErrorHandlerStack[runtimeErrorHandlerStack.length - 1] ?? null;
+  const stop = effect$1(
+    () => withRuntimeErrorHandler(handler, () => {
+      try {
+        const cleanup = fn();
+        if (typeof cleanup !== "function") {
+          return;
+        }
+        return () => withRuntimeErrorHandler(handler, () => {
+          try {
+            cleanup();
+          } catch (error) {
+            reportRuntimeError(error, handler);
+          }
+        });
+      } catch (error) {
+        reportRuntimeError(error, handler);
+      }
+    })
+  );
   return () => stop();
 }
 function computed(getter) {
   const version = signal(0);
   const source = computed$1(() => getter());
   effect$1(() => {
-    getter();
+    source.value;
     version.value = version.peek() + 1;
   });
   return new Signal(untracked(() => source.value), source, version);
@@ -162,6 +215,40 @@ function endHmrStateCapture() {
 // runtime/component.ts
 var EMPTY_SLOTS = Object.freeze({});
 var currentSetupContext = null;
+var currentLifecycleHooks = null;
+var ERROR_BOUNDARY = /* @__PURE__ */ Symbol("olova.error-boundary");
+var SUSPENSE_BOUNDARY = /* @__PURE__ */ Symbol("olova.suspense-boundary");
+function isPromiseLike(value) {
+  return !!value && typeof value === "object" && "then" in value;
+}
+function toOlovaError(error, context) {
+  if (error instanceof Error && error.message.startsWith("[olova]")) {
+    return error;
+  }
+  const original = error instanceof Error ? error : new Error(String(error));
+  const wrapped = new Error(`[olova] ${context}: ${original.message}`);
+  wrapped.cause = error;
+  return wrapped;
+}
+function getBoundaryHandler(context) {
+  return context?.get(ERROR_BOUNDARY) ?? null;
+}
+function handleRuntimeError(error, contextMessage, context) {
+  const normalized = toOlovaError(error, contextMessage);
+  const boundaryHandler = getBoundaryHandler(context);
+  if (boundaryHandler) {
+    boundaryHandler(normalized);
+    return;
+  }
+  throw normalized;
+}
+function runWithRuntimeErrorHandler(context, action, fn) {
+  try {
+    return withRuntimeErrorHandler(getBoundaryHandler(context), fn);
+  } catch (error) {
+    return handleRuntimeError(error, action, context);
+  }
+}
 function requireSetupContext(apiName) {
   if (!currentSetupContext) {
     throw new Error(
@@ -220,12 +307,12 @@ function sanitizeHtml(html) {
     }
     for (const attr of Array.from(element.attributes)) {
       const attrName = attr.name.toLowerCase();
-      const attrValue = attr.value.trim().toLowerCase();
+      const attrValue = attr.value.trim();
       if (attrName.startsWith("on")) {
         element.removeAttribute(attr.name);
         continue;
       }
-      if ((attrName === "href" || attrName === "src" || attrName === "xlink:href") && attrValue.startsWith("javascript:")) {
+      if ((attrName === "href" || attrName === "src" || attrName === "xlink:href") && !isSafeUrl(attrName, attrValue)) {
         element.removeAttribute(attr.name);
       }
     }
@@ -244,7 +331,27 @@ function toHtml(value) {
   }
   return sanitizeHtml(String(value));
 }
-function shallowEqual(a, b) {
+var SAFE_URL_PROTOCOLS = /* @__PURE__ */ new Set(["http", "https", "mailto", "tel"]);
+var SAFE_IMAGE_DATA_URL_RE = /^data:image\/(?:png|gif|jpe?g|webp|avif|bmp);(?:charset=[^;,]+;)?base64,[a-z0-9+/=\s]+$/i;
+function isSafeUrl(attrName, value) {
+  const normalized = value.replace(/[\u0000-\u001F\u007F\s]+/g, "");
+  if (!normalized) {
+    return true;
+  }
+  if (normalized.startsWith("#") || normalized.startsWith("/") || normalized.startsWith("./") || normalized.startsWith("../") || normalized.startsWith("?")) {
+    return true;
+  }
+  const match = normalized.match(/^([a-z0-9+.-]+):/i);
+  if (!match) {
+    return true;
+  }
+  const protocol = match[1].toLowerCase();
+  if (SAFE_URL_PROTOCOLS.has(protocol)) {
+    return true;
+  }
+  return protocol === "data" && attrName === "src" && SAFE_IMAGE_DATA_URL_RE.test(normalized);
+}
+function shallowEqualSlots(a, b) {
   if (a === b) {
     return true;
   }
@@ -263,20 +370,39 @@ function shallowEqual(a, b) {
   }
   return true;
 }
-function shallowEqualSlots(a, b) {
-  if (a === b) {
+function createComparablePropsSnapshot(props) {
+  return Object.fromEntries(
+    Object.entries(props).map(([key, value]) => [
+      key,
+      {
+        value,
+        reactiveVersion: getReactiveProxyVersion(value)
+      }
+    ])
+  );
+}
+function shallowComparablePropsEqual(snapshot, props) {
+  if (!snapshot && !props) {
     return true;
   }
-  if (!a || !b) {
+  if (!snapshot || !props) {
     return false;
   }
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length) {
+  const keys = Object.keys(snapshot);
+  const propKeys = Object.keys(props);
+  if (keys.length !== propKeys.length) {
     return false;
   }
-  for (const key of aKeys) {
-    if (!Object.is(a[key], b[key])) {
+  for (const key of keys) {
+    if (!(key in props)) {
+      return false;
+    }
+    const entry = snapshot[key];
+    const nextValue = props[key];
+    if (!Object.is(entry.value, nextValue)) {
+      return false;
+    }
+    if (entry.reactiveVersion !== getReactiveProxyVersion(nextValue)) {
       return false;
     }
   }
@@ -309,7 +435,7 @@ function bindJsxEventsInRange(range) {
   const listeners = [];
   const handlerIds = /* @__PURE__ */ new Set();
   const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
-  let current = walker.currentNode;
+  let current = walker.nextNode();
   while (current) {
     let intersects = false;
     try {
@@ -429,6 +555,42 @@ function createRangeAtTokenWithinRange(hostRange, token) {
 function resolveTokenRange(target, token) {
   return target instanceof HTMLElement ? createRangeAtToken(target, token) : createRangeAtTokenWithinRange(target, token);
 }
+function createLifecycleHooks() {
+  return {
+    mount: [],
+    cleanup: []
+  };
+}
+function flushLifecycleHooks(hooks, context) {
+  for (const mountHook of hooks.mount) {
+    const cleanup = runWithRuntimeErrorHandler(
+      context,
+      "Failed to run onMount() callback",
+      mountHook
+    );
+    if (typeof cleanup === "function") {
+      hooks.cleanup.push(cleanup);
+    }
+  }
+  return () => {
+    for (let index = hooks.cleanup.length - 1; index >= 0; index -= 1) {
+      runWithRuntimeErrorHandler(
+        context,
+        "Failed to run cleanup callback",
+        hooks.cleanup[index]
+      );
+    }
+  };
+}
+function createDescriptorEffect(context, fn) {
+  const stop = runWithRuntimeErrorHandler(
+    context,
+    "Failed to create reactive binding",
+    () => effect(fn)
+  );
+  return typeof stop === "function" ? stop : () => {
+  };
+}
 function mountDescriptor(descriptor, target, slots, context) {
   let fragment;
   let nodes = null;
@@ -448,7 +610,7 @@ function mountDescriptor(descriptor, target, slots, context) {
     if (!textNode) {
       continue;
     }
-    const stop = effect(() => {
+    const stop = createDescriptorEffect(context, () => {
       textNode.data = toText(binding.get());
     });
     cleanups.push(stop);
@@ -459,7 +621,7 @@ function mountDescriptor(descriptor, target, slots, context) {
       (element) => element.getAttribute(binding.attr) === token
     );
     for (const element of elements) {
-      const stop = effect(() => {
+      const stop = createDescriptorEffect(context, () => {
         const next = binding.attr === "class" ? normalizeClassValue(binding.get()) : toAttr(binding.get());
         if (next === null) {
           element.removeAttribute(binding.attr);
@@ -478,7 +640,7 @@ function mountDescriptor(descriptor, target, slots, context) {
     }
     if (!nodes) element.removeAttribute(`data-o-on-${binding.event}`);
     let currentHandler;
-    const stop = effect(() => {
+    const stop = createDescriptorEffect(context, () => {
       currentHandler = binding.get();
     });
     const listener = (event) => {
@@ -514,7 +676,7 @@ function mountDescriptor(descriptor, target, slots, context) {
     let lastHtml = "__OLOVA_INIT__";
     let cleanupJsxEvents = () => {
     };
-    const stop = effect(() => {
+    const stop = createDescriptorEffect(context, () => {
       const nextHtml = toHtml(binding.get());
       if (nextHtml === lastHtml) {
         return;
@@ -550,7 +712,15 @@ function mountDescriptor(descriptor, target, slots, context) {
       range.deleteContents();
       continue;
     }
-    const slotDescriptor = slotFactory();
+    const slotDescriptor = runWithRuntimeErrorHandler(
+      context,
+      `Failed to render slot "${binding.name}"`,
+      slotFactory
+    );
+    if (!slotDescriptor) {
+      range.deleteContents();
+      continue;
+    }
     const disposeSlot = mountDescriptor(slotDescriptor, range, slots, context);
     cleanups.push(disposeSlot);
   }
@@ -573,17 +743,17 @@ function mountDescriptor(descriptor, target, slots, context) {
     let lastComponent = null;
     let lastProps;
     let lastSlots;
-    const stop = effect(() => {
+    const stop = createDescriptorEffect(context, () => {
       const nextComponent = binding.getComponent();
       const nextProps = binding.getProps();
       const nextSlots = binding.getSlots ? binding.getSlots() : EMPTY_SLOTS;
-      if (lastComponent === nextComponent && shallowEqual(lastProps, nextProps) && shallowEqualSlots(lastSlots, nextSlots)) {
+      if (lastComponent === nextComponent && shallowComparablePropsEqual(lastProps, nextProps) && shallowEqualSlots(lastSlots, nextSlots)) {
         return;
       }
       disposeChild();
       disposeChild = mount(nextComponent, range, nextProps, nextSlots, context);
       lastComponent = nextComponent;
-      lastProps = { ...nextProps };
+      lastProps = createComparablePropsSnapshot(nextProps);
       lastSlots = nextSlots;
     });
     cleanups.push(() => {
@@ -609,17 +779,39 @@ function mountDescriptor(descriptor, target, slots, context) {
       let disposeBranch = () => {
       };
       let lastCondition = void 0;
-      const stop = effect(() => {
+      const stop = createDescriptorEffect(context, () => {
         const condition = !!binding.get();
         if (condition === lastCondition) {
           return;
         }
         disposeBranch();
         if (condition) {
-          const branchDescriptor = binding.trueBranch();
+          const branchDescriptor = runWithRuntimeErrorHandler(
+            context,
+            "Failed to render conditional branch",
+            binding.trueBranch
+          );
+          if (!branchDescriptor) {
+            range.deleteContents();
+            disposeBranch = () => {
+            };
+            lastCondition = condition;
+            return;
+          }
           disposeBranch = mountDescriptor(branchDescriptor, range, slots, context);
         } else if (binding.falseBranch) {
-          const branchDescriptor = binding.falseBranch();
+          const branchDescriptor = runWithRuntimeErrorHandler(
+            context,
+            "Failed to render conditional fallback branch",
+            binding.falseBranch
+          );
+          if (!branchDescriptor) {
+            range.deleteContents();
+            disposeBranch = () => {
+            };
+            lastCondition = condition;
+            return;
+          }
           disposeBranch = mountDescriptor(branchDescriptor, range, slots, context);
         } else {
           range.deleteContents();
@@ -655,22 +847,69 @@ function unregisterMountedInstance(instance) {
 function renderMountedInstance(instance, restoredValues) {
   const context = new Map(instance.parentContext ?? []);
   const previousContext = currentSetupContext;
+  const previousLifecycleHooks = currentLifecycleHooks;
+  const lifecycleHooks = createLifecycleHooks();
   currentSetupContext = context;
+  currentLifecycleHooks = lifecycleHooks;
   beginHmrStateCapture(restoredValues);
-  try {
-    const descriptor = instance.component.setup(instance.props, instance.slots);
-    instance.disposeDescriptor = mountDescriptor(
+  const finalizeRender = (descriptor) => {
+    const disposeDescriptor = mountDescriptor(
       descriptor,
       instance.target,
       instance.slots,
       context
     );
+    const disposeLifecycle = flushLifecycleHooks(lifecycleHooks, context);
+    instance.disposeDescriptor = () => {
+      disposeLifecycle();
+      disposeDescriptor();
+    };
+  };
+  try {
+    const descriptor = runWithRuntimeErrorHandler(
+      context,
+      "Failed to render component setup",
+      () => instance.component.setup(instance.props, instance.slots)
+    );
+    if (!descriptor) {
+      instance.disposeDescriptor = () => {
+      };
+      instance.hmrSignals = endHmrStateCapture();
+      return;
+    }
+    if (isPromiseLike(descriptor)) {
+      const suspenseBoundary = context.get(SUSPENSE_BOUNDARY);
+      const settleSuspense = suspenseBoundary?.begin() ?? (() => {
+      });
+      let disposed = false;
+      instance.disposeDescriptor = () => {
+        disposed = true;
+        settleSuspense();
+      };
+      instance.hmrSignals = endHmrStateCapture();
+      descriptor.then((resolvedDescriptor) => {
+        if (disposed) {
+          return;
+        }
+        settleSuspense();
+        finalizeRender(resolvedDescriptor);
+      }).catch((error) => {
+        settleSuspense();
+        if (disposed) {
+          return;
+        }
+        handleRuntimeError(error, "Failed to resolve async component", context);
+      });
+      return;
+    }
+    finalizeRender(descriptor);
     instance.hmrSignals = endHmrStateCapture();
   } catch (error) {
     endHmrStateCapture();
     throw error;
   } finally {
     currentSetupContext = previousContext;
+    currentLifecycleHooks = previousLifecycleHooks;
   }
 }
 function collectHmrSignalValues(instance) {
@@ -714,6 +953,124 @@ function replaceComponent(current, next) {
 function defineComponent(setup, hmrId) {
   return { setup, __hmrId: hmrId };
 }
+function isOlovaComponent(value) {
+  return typeof value === "object" && value !== null && "setup" in value;
+}
+function onMount(fn) {
+  if (!currentLifecycleHooks) {
+    throw new Error("[olova] onMount() can only be used during component setup.");
+  }
+  currentLifecycleHooks.mount.push(fn);
+}
+function onCleanup(fn) {
+  if (!currentLifecycleHooks) {
+    throw new Error("[olova] onCleanup() can only be used during component setup.");
+  }
+  currentLifecycleHooks.cleanup.push(fn);
+}
+function createErrorBoundary(component, fallback) {
+  return defineComponent((props, slots) => {
+    const errorState = state(null);
+    setContext(ERROR_BOUNDARY, (error) => {
+      errorState.value = error;
+    });
+    const renderFallback = () => {
+      const error = errorState.value ?? new Error("[olova] Unknown boundary error.");
+      if (isOlovaComponent(fallback)) {
+        return {
+          template: "__O_COMP_boundary_fallback__",
+          textBindings: [],
+          htmlBindings: [],
+          attrBindings: [],
+          eventBindings: [],
+          slotBindings: [],
+          componentBindings: [
+            {
+              id: "boundary_fallback",
+              getComponent: () => fallback,
+              getProps: () => ({ error })
+            }
+          ],
+          ifBindings: []
+        };
+      }
+      return fallback(error);
+    };
+    return {
+      template: "__O_IF_boundary__",
+      textBindings: [],
+      htmlBindings: [],
+      attrBindings: [],
+      eventBindings: [],
+      slotBindings: [],
+      componentBindings: [],
+      ifBindings: [
+        {
+          id: "boundary",
+          get: () => errorState.value === null,
+          trueBranch: () => ({
+            template: "__O_COMP_boundary_child__",
+            textBindings: [],
+            htmlBindings: [],
+            attrBindings: [],
+            eventBindings: [],
+            slotBindings: [],
+            componentBindings: [
+              {
+                id: "boundary_child",
+                getComponent: () => component,
+                getProps: () => props,
+                getSlots: () => slots
+              }
+            ],
+            ifBindings: []
+          }),
+          falseBranch: renderFallback
+        }
+      ]
+    };
+  }, component.__hmrId ? `${component.__hmrId}:boundary` : void 0);
+}
+var Suspense = defineComponent((_props, slots) => {
+  const pending = state(0);
+  setContext(SUSPENSE_BOUNDARY, {
+    begin() {
+      pending.value += 1;
+      let settled = false;
+      return () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        pending.value = Math.max(0, pending.value - 1);
+      };
+    }
+  });
+  return {
+    template: `<div style="__O_ATTR_default_style__">__O_SLOT_default__</div><div style="__O_ATTR_fallback_style__">__O_SLOT_fallback__</div>`,
+    textBindings: [],
+    htmlBindings: [],
+    attrBindings: [
+      {
+        id: "default_style",
+        attr: "style",
+        get: () => pending.value === 0 ? null : "display:none"
+      },
+      {
+        id: "fallback_style",
+        attr: "style",
+        get: () => pending.value > 0 ? null : "display:none"
+      }
+    ],
+    eventBindings: [],
+    slotBindings: [
+      { id: "default", name: "default" },
+      { id: "fallback", name: "fallback" }
+    ],
+    componentBindings: [],
+    ifBindings: []
+  };
+});
 function dangerouslySetHtml(value) {
   return {
     __dangerousHtml: true,
@@ -745,7 +1102,12 @@ function mount(component, target, props = {}, slots = EMPTY_SLOTS, parentContext
     hmrSignals: []
   };
   registerMountedInstance(instance);
-  renderMountedInstance(instance);
+  try {
+    renderMountedInstance(instance);
+  } catch (error) {
+    unregisterMountedInstance(instance);
+    throw toOlovaError(error, "Failed to mount component");
+  }
   return () => {
     unregisterMountedInstance(instance);
     instance.disposeDescriptor();
@@ -756,7 +1118,7 @@ function createApp(root) {
     mount(target) {
       const element = typeof target === "string" ? document.querySelector(target) : target;
       if (!element) {
-        throw new Error(`Target not found: ${String(target)}`);
+        throw new Error(`[olova] Target not found: ${String(target)}`);
       }
       return mount(root, element);
     }
@@ -819,9 +1181,6 @@ function setupPersistence(name, stateRef, target) {
 function ensureState(name, initial, options) {
   const existing = globalStates.get(name);
   if (existing) {
-    if (existing.value === void 0 && initial !== void 0) {
-      existing.value = initial;
-    }
     if (options?.persist) {
       if (existing.value === void 0) {
         const persisted = readPersisted(name, options.persist);
@@ -831,6 +1190,9 @@ function ensureState(name, initial, options) {
       }
       setupPersistence(name, existing, options.persist);
     }
+    if (existing.value === void 0 && initial !== void 0) {
+      existing.value = initial;
+    }
     return existing;
   }
   let resolvedInitial = initial;
@@ -859,6 +1221,6 @@ var global = {
   }
 };
 
-export { Signal, beginHmrStateCapture, computed, createApp, dangerouslySetHtml, defineComponent, derived, effect, endHmrStateCapture, getContext, global, hasContext, mount, replaceComponent, setContext, state };
+export { Signal, Suspense, beginHmrStateCapture, computed, createApp, createErrorBoundary, dangerouslySetHtml, defineComponent, derived, effect, endHmrStateCapture, getContext, getReactiveProxyVersion, global, hasContext, mount, onCleanup, onMount, replaceComponent, setContext, state, withRuntimeErrorHandler };
 //# sourceMappingURL=core.js.map
 //# sourceMappingURL=core.js.map