@simpreact/simpreact 0.0.3 → 0.0.5

package/core/patching.js

@@ -1,50 +1,44 @@
-import { emptyMap, emptyObject } from '../shared/index.js';
+import { emptyObject } from '../shared/index.js';
 import { normalizeRoot } from './createElement.js';
 import { hostAdapter } from './hostAdapter.js';
 import { clearElementHostReference, remove, unmount } from './unmounting.js';
-import { mount, mountArrayChildren } from './mounting.js';
+import { mount, mountArrayChildren, mountFunctionalElement } from './mounting.js';
 import { applyRef } from './ref.js';
 import { lifecycleEventBus } from './lifecycleEventBus.js';
-import { batchingRerenderLocker } from './rerender.js';
-export function patch(prevElement, nextElement, parentReference, nextReference, contextMap, hostNamespace) {
+import { isMemo } from './memo.js';
+export function patch(prevElement, nextElement, parentReference, nextReference, context, hostNamespace) {
     if (prevElement.type !== nextElement.type || prevElement.key !== nextElement.key) {
-        replaceWithNewElement(prevElement, nextElement, parentReference, contextMap, hostNamespace);
+        replaceWithNewElement(prevElement, nextElement, parentReference, context, hostNamespace);
     }
     else if (nextElement.flag === 'HOST') {
-        patchHostElement(prevElement, nextElement, contextMap, hostNamespace);
+        patchHostElement(prevElement, nextElement, context, hostNamespace);
     }
     else if (nextElement.flag === 'FC') {
-        patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference, contextMap, hostNamespace);
+        patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference, context, hostNamespace);
     }
     else if (nextElement.flag === 'TEXT') {
         patchTextElement(prevElement, nextElement);
     }
     else if (nextElement.flag === 'FRAGMENT') {
-        patchFragment(prevElement, nextElement, parentReference, contextMap, hostNamespace);
-    }
-    else if (nextElement.flag === 'PROVIDER') {
-        patchProvider(prevElement, nextElement, parentReference, contextMap, hostNamespace);
-    }
-    else if (nextElement.flag === 'PORTAL') {
-        patchPortal(prevElement, nextElement, contextMap);
+        patchFragment(prevElement, nextElement, parentReference, context, hostNamespace);
     }
     else {
-        patchConsumer(prevElement, nextElement, parentReference, nextReference, contextMap, hostNamespace);
+        patchPortal(prevElement, nextElement, context);
     }
 }
-function replaceWithNewElement(prevElement, nextElement, parentReference, contextMap, hostNamespace) {
+function replaceWithNewElement(prevElement, nextElement, parentReference, context, hostNamespace) {
     unmount(prevElement);
     nextElement.parent = prevElement.parent;
     if (nextElement.flag === 'HOST' && prevElement.flag === 'HOST') {
-        mount(nextElement, null, null, contextMap, hostNamespace);
+        mount(nextElement, null, null, context, hostNamespace);
         hostAdapter.replaceChild(parentReference, nextElement.reference, prevElement.reference);
     }
     else {
-        mount(nextElement, parentReference, findHostReferenceFromElement(prevElement), contextMap, hostNamespace);
+        mount(nextElement, parentReference, findHostReferenceFromElement(prevElement), context, hostNamespace);
         clearElementHostReference(prevElement, parentReference);
     }
 }
-function patchHostElement(prevElement, nextElement, contextMap, hostNamespace) {
+function patchHostElement(prevElement, nextElement, context, hostNamespace) {
     if (prevElement.ref) {
         nextElement.ref = prevElement.ref;
     }
@@ -52,25 +46,32 @@ function patchHostElement(prevElement, nextElement, contextMap, hostNamespace) {
     hostNamespace = hostNamespaces?.self;
     nextElement.reference = prevElement.reference;
     hostAdapter.attachElementToReference(nextElement, nextElement.reference);
-    patchChildren(prevElement.children || prevElement.props?.children, nextElement.children || nextElement.props?.children, nextElement.reference, null, nextElement, contextMap, hostNamespaces?.children);
+    patchChildren(prevElement.children || prevElement.props?.children, nextElement.children || nextElement.props?.children, nextElement.reference, null, nextElement, context, hostNamespaces?.children);
     hostAdapter.patchProps(nextElement.reference, prevElement, nextElement, hostNamespace);
     if (prevElement.className !== nextElement.className) {
         hostAdapter.setClassname(nextElement.reference, nextElement.className, hostNamespace);
     }
     applyRef(nextElement);
 }
-function patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference, contextMap, hostNamespace) {
-    const prevStore = !prevElement.store || prevElement.unmounted
-        ? { hostNamespace: prevElement.store?.hostNamespace }
-        : prevElement.store;
-    prevStore.latestElement = nextElement;
-    nextElement.store = prevStore;
+function patchFunctionalComponent(prevElement, nextElement, parentReference, nextReference, context, hostNamespace) {
+    nextElement.store = prevElement.store || {};
+    nextElement.store.latestElement = nextElement;
     if (hostNamespace) {
         nextElement.store.hostNamespace = hostNamespace;
     }
-    if (contextMap) {
-        nextElement.contextMap = contextMap;
+    let forceRender = false;
+    if (prevElement.store?.forceRender) {
+        forceRender = true;
+        prevElement.store.forceRender = false;
     }
+    if (prevElement.unmounted) {
+        mountFunctionalElement(nextElement, parentReference, nextReference, context, hostNamespace);
+        return;
+    }
+    if (!forceRender && isMemo(nextElement.type) && nextElement.type._compare(prevElement.props, nextElement.props)) {
+        return;
+    }
+    nextElement.context = prevElement.context || context;
     // FC element always has Maybe<SimpElement> children due to normalization process.
     let nextChildren;
     let triedToRerenderUnsubscribe;
@@ -85,44 +86,29 @@ function patchFunctionalComponent(prevElement, nextElement, parentReference, nex
         do {
             triedToRerender = false;
             if (++rerenderCounter >= 25) {
-                lifecycleEventBus.publish({
-                    type: 'errored',
-                    element: nextElement,
-                    error: new Error('Too many re-renders. SimpReact limits the number of renders to prevent an infinite loop.'),
-                    phase: 'updating',
-                });
-                return;
+                throw new Error('Too many re-renders.');
             }
             lifecycleEventBus.publish({ type: 'beforeRender', element: nextElement, phase: 'updating' });
-            batchingRerenderLocker.lock();
             nextChildren = nextElement.type(nextElement.props || emptyObject);
-            batchingRerenderLocker.flush();
             lifecycleEventBus.publish({ type: 'afterRender', element: nextElement, phase: 'updating' });
         } while (triedToRerender);
         nextChildren = normalizeRoot(nextChildren, false);
     }
     catch (error) {
         lifecycleEventBus.publish({ type: 'errored', element: nextElement, error, phase: 'updating' });
+        remove(prevElement, parentReference);
         return;
     }
     finally {
         triedToRerenderUnsubscribe();
     }
+    // Keep prevElement's children reference when prev and next elements are identical to avoid reassignment.
     const prevChildren = prevElement.children;
     if (nextChildren) {
         nextElement.children = nextChildren;
     }
-    if (!prevElement.unmounted) {
-        patchChildren(prevChildren, nextChildren, parentReference, nextReference, nextElement, contextMap, hostNamespace);
-        lifecycleEventBus.publish({ type: 'updated', element: nextElement });
-        return;
-    }
-    prevElement.unmounted = false;
-    if (nextChildren) {
-        nextChildren.parent = nextElement;
-        mount(nextChildren, parentReference, nextReference, contextMap, hostNamespace);
-    }
-    lifecycleEventBus.publish({ type: 'mounted', element: nextElement });
+    patchChildren(prevChildren, nextChildren, parentReference, nextReference, nextElement, nextElement.context, hostNamespace);
+    lifecycleEventBus.publish({ type: 'updated', element: nextElement });
 }
 function patchTextElement(prevElement, nextElement) {
     nextElement.reference = prevElement.reference;
@@ -130,57 +116,41 @@ function patchTextElement(prevElement, nextElement) {
         hostAdapter.setTextContent(nextElement.reference, nextElement.children);
     }
 }
-function patchFragment(prevElement, nextElement, parentReference, contextMap, hostNamespace) {
-    let nextReference = null;
-    if (Array.isArray(prevElement.children) && !Array.isArray(nextElement.children) && nextElement.children) {
-        nextReference = hostAdapter.findNextSiblingReference(findHostReferenceFromElement(prevElement.children[prevElement.children.length - 1]));
-    }
-    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, nextElement, contextMap, hostNamespace);
-}
-function patchProvider(prevElement, nextElement, parentReference, contextMap, hostNamespace) {
+function patchFragment(prevElement, nextElement, parentReference, context, hostNamespace) {
     let nextReference = null;
     if (Array.isArray(prevElement.children) && !Array.isArray(nextElement.children) && nextElement.children) {
         nextReference = hostAdapter.findNextSiblingReference(findHostReferenceFromElement(prevElement.children[prevElement.children.length - 1]));
     }
-    contextMap = new Map(contextMap);
-    contextMap.set(nextElement.type.context, nextElement.props.value);
-    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, nextElement, contextMap, hostNamespace);
-}
-function patchConsumer(prevElement, nextElement, parentReference, nextReference, contextMap, hostNamespace) {
-    const children = normalizeRoot(nextElement.type(nextElement.props || emptyObject, contextMap || emptyMap), false);
-    if (children) {
-        nextElement.children = children;
-    }
-    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, nextElement, contextMap, hostNamespace);
+    patchChildren(prevElement.children, nextElement.children, parentReference, nextReference, nextElement, context, hostNamespace);
 }
-export function patchPortal(prevElement, nextElement, contextMap) {
+export function patchPortal(prevElement, nextElement, context) {
     const prevContainer = prevElement.ref;
     const nextContainer = nextElement.ref;
     const nextChildren = nextElement.children;
-    patchChildren(prevElement.children, nextChildren, prevContainer, null, nextElement, contextMap, hostAdapter.getHostNamespaces(nextChildren, undefined)?.self);
+    patchChildren(prevElement.children, nextChildren, prevContainer, null, nextElement, context, hostAdapter.getHostNamespaces(nextChildren, undefined)?.self);
     nextElement.reference = prevElement.reference;
     if (prevContainer !== nextContainer && nextChildren != null) {
         hostAdapter.removeChild(prevContainer, nextChildren.reference);
         hostAdapter.appendChild(nextContainer, nextChildren.reference);
     }
 }
-export function updateFunctionalComponent(element, parentReference, nextReference, contextMap, hostNamespace) {
-    patchFunctionalComponent(element, element, parentReference, nextReference, contextMap, hostNamespace);
+export function updateFunctionalComponent(element, parentReference, nextReference, context, hostNamespace) {
+    patchFunctionalComponent(element, element, parentReference, nextReference, context, hostNamespace);
 }
-function patchChildren(prevChildren, nextChildren, parentReference, nextReference, nextElement, contextMap, hostNamespace) {
+function patchChildren(prevChildren, nextChildren, parentReference, nextReference, nextElement, context, hostNamespace) {
     if (Array.isArray(prevChildren)) {
         if (Array.isArray(nextChildren)) {
             for (const child of nextChildren) {
                 child.parent = nextElement;
             }
-            patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference, contextMap, hostNamespace);
+            patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference, context, hostNamespace);
         }
         else if (typeof nextChildren === 'string') {
             unmount(prevChildren);
             hostAdapter.setTextContent(parentReference, nextChildren);
         }
         else if (nextChildren) {
-            patchKeyedChildren(prevChildren, [nextChildren], parentReference, nextReference, contextMap, hostNamespace);
+            patchKeyedChildren(prevChildren, [nextChildren], parentReference, nextReference, context, hostNamespace);
         }
         else {
             unmount(prevChildren);
@@ -190,7 +160,7 @@ function patchChildren(prevChildren, nextChildren, parentReference, nextReferenc
     else if (typeof prevChildren === 'string') {
         if (Array.isArray(nextChildren)) {
             hostAdapter.clearNode(parentReference);
-            mountArrayChildren(nextChildren, parentReference, nextReference, contextMap, nextElement, hostNamespace);
+            mountArrayChildren(nextChildren, parentReference, nextReference, context, nextElement, hostNamespace);
         }
         else if (typeof nextChildren === 'string') {
             if (prevChildren !== nextChildren) {
@@ -200,7 +170,7 @@ function patchChildren(prevChildren, nextChildren, parentReference, nextReferenc
         else if (nextChildren) {
             hostAdapter.clearNode(parentReference);
             nextChildren.parent = nextElement;
-            mount(nextChildren, parentReference, nextReference, contextMap, hostNamespace);
+            mount(nextChildren, parentReference, nextReference, context, hostNamespace);
         }
         else {
             hostAdapter.clearNode(parentReference);
@@ -208,7 +178,7 @@ function patchChildren(prevChildren, nextChildren, parentReference, nextReferenc
     }
     else if (prevChildren) {
         if (Array.isArray(nextChildren)) {
-            patchKeyedChildren([prevChildren], nextChildren, parentReference, nextReference, contextMap, hostNamespace);
+            patchKeyedChildren([prevChildren], nextChildren, parentReference, nextReference, context, hostNamespace);
         }
         else if (typeof nextChildren === 'string') {
             unmount(prevChildren);
@@ -216,7 +186,7 @@ function patchChildren(prevChildren, nextChildren, parentReference, nextReferenc
         }
         else if (nextChildren) {
             nextChildren.parent = nextElement;
-            patch(prevChildren, nextChildren, parentReference, nextReference, contextMap, hostNamespace);
+            patch(prevChildren, nextChildren, parentReference, nextReference, context, hostNamespace);
         }
         else {
             remove(prevChildren, parentReference);
@@ -224,18 +194,18 @@ function patchChildren(prevChildren, nextChildren, parentReference, nextReferenc
     }
     else {
         if (Array.isArray(nextChildren)) {
-            mountArrayChildren(nextChildren, parentReference, nextReference, contextMap, nextElement, hostNamespace);
+            mountArrayChildren(nextChildren, parentReference, nextReference, context, nextElement, hostNamespace);
         }
         else if (typeof nextChildren === 'string') {
             hostAdapter.setTextContent(parentReference, nextChildren);
         }
         else if (nextChildren) {
             nextChildren.parent = nextElement;
-            mount(nextChildren, parentReference, nextReference, contextMap, hostNamespace);
+            mount(nextChildren, parentReference, nextReference, context, hostNamespace);
         }
     }
 }
-export function patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference, contextMap, hostNamespace) {
+export function patchKeyedChildren(prevChildren, nextChildren, parentReference, nextReference, context, hostNamespace) {
     let prevStart = 0;
     let nextStart = 0;
     let prevEnd = prevChildren.length - 1;
@@ -244,13 +214,13 @@ export function patchKeyedChildren(prevChildren, nextChildren, parentReference,
     while (prevStart <= prevEnd &&
         nextStart <= nextEnd &&
         prevChildren[prevStart].key === nextChildren[nextStart].key) {
-        patch(prevChildren[prevStart], nextChildren[nextStart], parentReference, null, contextMap, hostNamespace);
+        patch(prevChildren[prevStart], nextChildren[nextStart], parentReference, null, context, hostNamespace);
         prevStart++;
         nextStart++;
     }
     // Step 2: Sync from end
     while (prevStart <= prevEnd && nextStart <= nextEnd && prevChildren[prevEnd].key === nextChildren[nextEnd].key) {
-        patch(prevChildren[prevEnd], nextChildren[nextEnd], parentReference, null, contextMap, hostNamespace);
+        patch(prevChildren[prevEnd], nextChildren[nextEnd], parentReference, null, context, hostNamespace);
         prevEnd--;
         nextEnd--;
     }
@@ -258,7 +228,7 @@ export function patchKeyedChildren(prevChildren, nextChildren, parentReference,
     if (prevStart > prevEnd) {
         const before = findHostReferenceFromElement(nextChildren[nextEnd + 1]) || nextReference;
         for (let i = nextStart; i <= nextEnd; i++) {
-            mount(nextChildren[i], parentReference, before, contextMap, hostNamespace);
+            mount(nextChildren[i], parentReference, before, context, hostNamespace);
         }
         // Step 4: Remove prev nodes if next list is exhausted
     }
@@ -286,12 +256,12 @@ export function patchKeyedChildren(prevChildren, nextChildren, parentReference,
             const prevIndex = keyToPrevIndexMap.get(nextChild.key);
             if (prevIndex != null) {
                 const prevElement = prevChildren[prevIndex];
-                patch(prevElement, nextChild, parentReference, null, contextMap, hostNamespace);
+                patch(prevElement, nextChild, parentReference, null, context, hostNamespace);
                 toMove[i - nextStart] = prevIndex;
                 usedIndices.add(prevIndex);
             }
             else {
-                mount(nextChild, parentReference, findHostReferenceFromElement(nextChildren[i + 1]) || nextReference, contextMap, hostNamespace);
+                mount(nextChild, parentReference, findHostReferenceFromElement(nextChildren[i + 1]) || nextReference, context, hostNamespace);
                 toMove[i - nextStart] = -1;
             }
         }

package/core/rerender.d.ts

@@ -1,10 +1,11 @@
-import type { SimpElement } from './createElement.js';
+import type { SimpElement, SimpElementStore } from './createElement.js';
 export declare function rerender(element: SimpElement): void;
 interface IRendererLocker {
     _isLocked: boolean;
-    _elements: Set<SimpElement>;
-    _track(element: SimpElement): void;
-    _untrack(element: SimpElement): void;
+    _elementStores: Set<SimpElementStore>;
+    _last: SimpElementStore | undefined;
+    _track(element: SimpElementStore): void;
+    _untrack(element: SimpElementStore): void;
     lock(): void;
     flush(): void;
 }

package/core/rerender.js

@@ -1,9 +1,9 @@
 import { findParentReferenceFromElement, updateFunctionalComponent } from './patching.js';
 import { lifecycleEventBus } from './lifecycleEventBus.js';
 lifecycleEventBus.subscribe(event => {
-    if (event.type === 'afterRender') {
-        batchingRerenderLocker._untrack(event.element);
-        renderingRerenderLocker._untrack(event.element);
+    if (event.type === 'afterRender' || event.type === 'errored' || event.type === 'unmounted') {
+        batchingRerenderLocker._untrack(event.element.store);
+        renderingRerenderLocker._untrack(event.element.store);
     }
 });
 export function rerender(element) {
@@ -15,62 +15,114 @@ export function rerender(element) {
     }
     lifecycleEventBus.publish({ type: 'triedToRerender', element });
     if (batchingRerenderLocker._isLocked) {
-        batchingRerenderLocker._track(element);
+        batchingRerenderLocker._track(element.store);
         return;
     }
     if (renderingRerenderLocker._isLocked) {
-        renderingRerenderLocker._track(element);
+        renderingRerenderLocker._track(element.store);
         return;
     }
     renderingRerenderLocker.lock();
-    updateFunctionalComponent(element, findParentReferenceFromElement(element), null, element.contextMap || null, element.store.hostNamespace);
+    updateFunctionalComponent(element, findParentReferenceFromElement(element), null, element.context || null, element.store.hostNamespace);
     renderingRerenderLocker.flush();
 }
 export const batchingRerenderLocker = {
     _isLocked: false,
-    _elements: new Set(),
-    _track(element) {
-        this._elements.add(element);
+    _elementStores: new Set(),
+    _last: undefined,
+    _track(store) {
+        if (this._elementStores.has(store)) {
+            return;
+        }
+        if (this._elementStores.size === 0 || store.forceRender) {
+            this._elementStores.add(store);
+            this._last = store;
+            return;
+        }
+        if (isParentOf(store.latestElement, this._last.latestElement)) {
+            return;
+        }
+        if (isParentOf(this._last.latestElement, store.latestElement)) {
+            this._elementStores.clear();
+            this._elementStores.add(store);
+            this._last = store;
+        }
     },
-    _untrack(element) {
-        this._elements.delete(element);
+    _untrack(store) {
+        if (this._elementStores.delete(store) && store === this._last) {
+            this._last = undefined;
+            for (const val of this._elementStores) {
+                this._last = val;
+            }
+        }
     },
     lock() {
         this._isLocked = true;
     },
     flush() {
         this._isLocked = false;
-        if (this._elements.size === 0) {
+        if (this._elementStores.size === 0) {
             return;
         }
-        for (const element of this._elements) {
-            this._untrack(element);
-            rerender(element.store.latestElement);
+        for (const store of this._elementStores) {
+            this._untrack(store);
+            rerender(store.latestElement);
         }
     },
 };
 export const renderingRerenderLocker = {
     _isLocked: false,
-    _elements: new Set(),
-    _track(element) {
-        this._elements.add(element);
+    _elementStores: new Set(),
+    _last: undefined,
+    _track(store) {
+        if (this._elementStores.has(store)) {
+            return;
+        }
+        if (this._elementStores.size === 0 || store.forceRender) {
+            this._elementStores.add(store);
+            this._last = store;
+            return;
+        }
+        if (isParentOf(store.latestElement, this._last.latestElement)) {
+            return;
+        }
+        if (isParentOf(this._last.latestElement, store.latestElement)) {
+            this._elementStores.clear();
+            this._elementStores.add(store);
+            this._last = store;
+        }
     },
-    _untrack(element) {
-        this._elements.delete(element);
+    _untrack(store) {
+        if (this._elementStores.delete(store) && store === this._last) {
+            this._last = undefined;
+            for (const val of this._elementStores) {
+                this._last = val;
+            }
+        }
     },
     lock() {
         this._isLocked = true;
     },
     flush() {
         this._isLocked = false;
-        if (this._elements.size === 0) {
+        if (this._elementStores.size === 0) {
             return;
         }
         queueMicrotask(() => {
-            for (const element of this._elements) {
-                this._untrack(element);
-                rerender(element.store.latestElement);
+            for (const store of this._elementStores) {
+                this._untrack(store);
+                rerender(store.latestElement);
             }
         });
     },
 };
+function isParentOf(element, parent) {
+    let current = element.parent;
+    while (current) {
+        if (current.store === parent.store) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}

package/core/unmounting.js

@@ -28,7 +28,7 @@ export function unmount(element) {
         remove(element.children, element.ref);
         return;
     }
-    // Only FRAGMENT, PROVIDER, CONSUMER, and HOST elements remain,
+    // Only FRAGMENT and HOST elements remain,
     // with Maybe<Many<SimpElement>> children due to normalization.
     if (element.children) {
         unmount(element.children);
@@ -45,11 +45,11 @@ export function clearElementHostReference(element, parentHostReference) {
             return;
         }
         const children = element.children;
-        if (element.flag === 'FC' || element.flag === 'CONSUMER') {
+        if (element.flag === 'FC') {
             element = children;
             continue;
         }
-        if (element.flag === 'FRAGMENT' || element.flag === 'PROVIDER') {
+        if (element.flag === 'FRAGMENT') {
             if (Array.isArray(children)) {
                 for (let i = 0, len = children.length; i < len; ++i) {
                     clearElementHostReference(children[i], parentHostReference);

package/dom/attach-element-to-dom.js

@@ -5,5 +5,14 @@ export function attachElementToDom(element, dom) {
     }
 }
 export function getElementFromDom(target) {
-    return target?.[elementPropertyName] ?? null;
+    if (!target) {
+        return null;
+    }
+    while (target && !(elementPropertyName in target)) {
+        target = target.parentElement;
+    }
+    if (!target) {
+        return null;
+    }
+    return target[elementPropertyName];
 }

package/dom/events.d.ts

@@ -4,15 +4,20 @@ export declare class SyntheticEvent {
     nativeEvent: Event;
     currentTarget: Nullable<EventTarget>;
     isPropagationStopped: boolean;
-    isDefaultPrevented: boolean;
+    _isDefaultPrevented: boolean;
     button?: number;
     buttons?: number;
     pointerId?: number;
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    metaKey?: boolean;
     constructor(event: Event);
     get target(): EventTarget | null;
     get type(): string;
     stopPropagation(): void;
     preventDefault(): void;
+    isDefaultPrevented(): boolean;
 }
 export declare function dispatchDelegatedEvent(event: Event): void;
 export declare function patchEvent(name: string, prevValue: any, nextValue: any, dom: Element): void;

package/dom/events.js

@@ -39,15 +39,22 @@ export class SyntheticEvent {
     nativeEvent;
     currentTarget = null;
     isPropagationStopped = false;
-    isDefaultPrevented = false;
+    _isDefaultPrevented = false;
     button;
     buttons;
     pointerId;
+    altKey;
+    ctrlKey;
+    shiftKey;
+    metaKey;
     constructor(event) {
         this.nativeEvent = event;
         this.button = event.button;
         this.buttons = event.buttons;
         this.pointerId = event.pointerId;
+        this.altKey = event.altKey;
+        this.ctrlKey = event.ctrlKey;
+        this.metaKey = event.metaKey;
     }
     get target() {
         return this.nativeEvent.target;
@@ -60,9 +67,12 @@ export class SyntheticEvent {
         this.nativeEvent.stopPropagation();
     }
     preventDefault() {
-        this.isDefaultPrevented = true;
+        this._isDefaultPrevented = true;
         this.nativeEvent.preventDefault();
     }
+    isDefaultPrevented() {
+        return this._isDefaultPrevented;
+    }
 }
 export function dispatchDelegatedEvent(event) {
     batchingRerenderLocker.lock();

package/hooks/index.d.ts

@@ -1,4 +1,4 @@
-import type { RefObject, SimpContext } from '../core/index.js';
+import type { RefObject } from '../core/index.js';
 
 export type Cleanup = () => void;
 export type Effect = () => void | Cleanup;
@@ -22,8 +22,6 @@ declare function useMounted(effect: Effect): void;
 
 declare function useUnmounted(cleanup: Cleanup): void;
 
-declare function useContext<T>(context: SimpContext<T>): T;
-
 declare function useCatch(cb: (error: any) => void): void;
 
 declare function areDepsEqual(nextDeps: DependencyList | undefined, prevDeps: DependencyList | undefined): boolean;