@jasonshimmy/custom-elements-runtime 1.2.3 → 2.0.1

package/dist/runtime/reactive.d.ts

@@ -42,11 +42,11 @@ declare class ReactiveSystem {
     /**
      * Track a dependency for the current component
      */
-    trackDependency(state: ReactiveState<any>): void;
+    trackDependency(state: ReactiveState<unknown>): void;
     /**
      * Trigger updates for all components that depend on a state
      */
-    triggerUpdate(state: ReactiveState<any>): void;
+    triggerUpdate(state: ReactiveState<unknown>): void;
     /**
      * Clean up component dependencies when component is destroyed
      */
@@ -85,12 +85,13 @@ export declare class ReactiveState<T> {
  * console.log(emptyRef.value); // null
  * ```
  */
-export declare function ref<T = null>(initialValue?: T): ReactiveState<T extends undefined ? null : T>;
+export declare function ref(): ReactiveState<null>;
+export declare function ref<T>(initialValue: T): ReactiveState<T>;
 /**
  * Type guard to detect ReactiveState instances in a robust way that works
  * across bundlers, minifiers, and multiple package copies.
  */
-export declare function isReactiveState(v: any): v is ReactiveState<any>;
+export declare function isReactiveState(v: unknown): v is ReactiveState<unknown>;
 /**
  * Create computed state that derives from other reactive state
  *

package/dist/runtime/render.d.ts

@@ -1,13 +1,13 @@
-import type { ComponentConfig, ComponentContext, VNode, Refs } from "./types";
-export declare const contextStack: any[];
+import type { ComponentConfig, ComponentContext, VNode, Refs } from './types';
+export declare const contextStack: unknown[];
 /**
  * Renders the component output.
  */
-export declare function renderComponent<S extends object, C extends object, P extends object, T extends object>(shadowRoot: ShadowRoot | null, cfg: ComponentConfig<S, C, P, T>, context: ComponentContext<S, C, P, T>, refs: Refs["refs"], setHtmlString: (html: string) => void, setLoading: (val: boolean) => void, setError: (err: Error | null) => void, applyStyle: (html: string) => void): void;
+export declare function renderComponent<S extends object, C extends object, P extends object, T extends object>(shadowRoot: ShadowRoot | null, cfg: ComponentConfig<S, C, P, T>, context: ComponentContext<S, C, P, T>, refs: Refs['refs'], setHtmlString: (html: string) => void, setLoading: (val: boolean) => void, setError: (err: Error | null) => void, applyStyle: (html: string) => void): void;
 /**
  * Renders VNode(s) to the shadowRoot.
  */
-export declare function renderOutput<S extends object, C extends object, P extends object, T extends object>(shadowRoot: ShadowRoot | null, output: VNode | VNode[], context: ComponentContext<S, C, P, T>, refs: Refs["refs"], setHtmlString: (html: string) => void): void;
+export declare function renderOutput<S extends object, C extends object, P extends object, T extends object>(shadowRoot: ShadowRoot | null, output: VNode | VNode[], context: ComponentContext<S, C, P, T>, refs: Refs['refs'], setHtmlString: (html: string) => void): void;
 /**
  * Debounced render request with infinite loop protection.
  */

package/dist/runtime/secure-expression-evaluator.d.ts

@@ -9,7 +9,7 @@ declare class SecureExpressionEvaluator {
     private static cache;
     private static maxCacheSize;
     private static dangerousPatterns;
-    static evaluate(expression: string, context: any): any;
+    static evaluate(expression: string, context: Record<string, unknown>): unknown;
     private static createEvaluator;
     private static hasDangerousPatterns;
     private static createSafeEvaluator;

package/dist/runtime/template-compiler.d.ts

@@ -1,19 +1,19 @@
-import type { VNode } from "./types";
-export declare function h(tag: string, props?: Record<string, any>, children?: VNode[] | string, key?: string | number): VNode;
-export declare function isAnchorBlock(v: any): boolean;
-export declare function isElementVNode(v: any): v is VNode;
-export declare function ensureKey(v: VNode, k: string): VNode;
+import type { VNode } from './types';
+export declare function h(tag: string, props?: Record<string, unknown>, children?: VNode[] | string, key?: string | number): VNode;
+export declare function isAnchorBlock(v: unknown): boolean;
+export declare function isElementVNode(v: unknown): v is VNode;
+export declare function ensureKey(v: VNode, k?: string): VNode;
 export interface ParsePropsResult {
-    props: Record<string, any>;
-    attrs: Record<string, any>;
+    props: Record<string, unknown>;
+    attrs: Record<string, unknown>;
     directives: Record<string, {
-        value: any;
+        value: unknown;
         modifiers: string[];
         arg?: string;
     }>;
     bound: string[];
 }
-export declare function parseProps(str: string, values?: unknown[], context?: Record<string, any>): ParsePropsResult;
+export declare function parseProps(str: string, values?: unknown[], context?: Record<string, unknown>): ParsePropsResult;
 /**
  * Internal implementation allowing an optional compile context for :model.
  * Fixes:
@@ -22,7 +22,7 @@ export declare function parseProps(str: string, values?: unknown[], context?: Re
  *  - Pass AnchorBlocks through (and deep-normalize their children's keys) so the renderer can mount/patch them surgically.
  *  - Do not rewrap interpolated VNodes (preserve their keys); only fill in missing keys.
  */
-export declare function htmlImpl(strings: TemplateStringsArray, values: unknown[], context?: Record<string, any>): VNode | VNode[];
+export declare function htmlImpl(strings: TemplateStringsArray, values: unknown[], context?: Record<string, unknown>): VNode | VNode[];
 /**
  * Clear the template compile cache (useful for tests)
  */

package/dist/runtime/transition-group-handler.d.ts

@@ -0,0 +1,21 @@
+import type { VNode, VDomRefs } from './types';
+/**
+ * Handle TransitionGroup keyed diffing and FLIP animations.
+ * This function is intentionally passed `createElement` and `patch`
+ * to avoid circular imports with the main vdom renderer.
+ */
+export declare function handleTransitionGroup(params: {
+    parent: HTMLElement;
+    oldNodesCache: Node[];
+    oldVNodes: VNode[];
+    newChildren: VNode[];
+    context?: Record<string, unknown>;
+    refs?: VDomRefs;
+    transitionGroup: {
+        moveClass?: string;
+        appear?: boolean;
+        [key: string]: unknown;
+    };
+    createElement: (v: VNode, c?: Record<string, unknown>, r?: VDomRefs) => Node;
+    patch: (n: Node, o: VNode | string | null, nn: VNode | string | null, c?: Record<string, unknown>, r?: VDomRefs) => Node;
+}): boolean;

package/dist/runtime/transition-utils.d.ts

@@ -1,12 +1,52 @@
+/**
+ * Transition lifecycle hook signatures
+ */
+interface TransitionHooks {
+    onBeforeEnter?: (el: HTMLElement) => void;
+    onEnter?: (el: HTMLElement, done?: () => void) => void;
+    onAfterEnter?: (el: HTMLElement) => void;
+    onBeforeLeave?: (el: HTMLElement) => void;
+    onLeave?: (el: HTMLElement, done?: () => void) => void;
+    onAfterLeave?: (el: HTMLElement) => void;
+    onEnterCancelled?: (el: HTMLElement) => void;
+    onLeaveCancelled?: (el: HTMLElement) => void;
+}
 /**
  * Perform enter transition on an element
  */
-export declare function performEnterTransition(el: HTMLElement, transitionMeta: any): Promise<void>;
+export declare function performEnterTransition(el: HTMLElement, transitionMeta: {
+    classes?: Record<string, string | undefined>;
+    hooks?: TransitionHooks;
+    css?: boolean;
+    duration?: number | {
+        enter?: number;
+        leave?: number;
+    };
+    [key: string]: unknown;
+}): Promise<void>;
 /**
  * Perform leave transition on an element
  */
-export declare function performLeaveTransition(el: HTMLElement, transitionMeta: any): Promise<void>;
+export declare function performLeaveTransition(el: HTMLElement, transitionMeta: {
+    classes?: Record<string, string | undefined>;
+    hooks?: TransitionHooks;
+    css?: boolean;
+    duration?: number | {
+        enter?: number;
+        leave?: number;
+    };
+    [key: string]: unknown;
+}): Promise<void>;
 /**
  * Cancel ongoing transition
  */
-export declare function cancelTransition(el: HTMLElement, isEnter: boolean, transitionMeta: any): void;
+export declare function cancelTransition(el: HTMLElement, isEnter: boolean, transitionMeta: {
+    classes?: Record<string, string | undefined>;
+    hooks?: TransitionHooks;
+    duration?: number | {
+        enter?: number;
+        leave?: number;
+    };
+    [key: string]: unknown;
+}): void;
+export {};

package/dist/runtime/types.d.ts

@@ -6,25 +6,33 @@ export interface VNode {
     key?: string;
     props?: {
         key?: string;
-        props?: any;
-        attrs?: Record<string, any>;
+        props?: Record<string, unknown>;
+        attrs?: Record<string, string | number | boolean | null | undefined>;
         directives?: Record<string, {
             value: string;
             modifiers: string[];
             arg?: string;
         }>;
         ref?: string;
-        reactiveRef?: any;
+        reactiveRef?: {
+            value: unknown;
+            [key: string]: unknown;
+        };
         /** Compiler-provided hint: whether this VNode represents a custom element (contains a dash) */
         isCustomElement?: boolean;
         /** Transition group metadata */
-        _transitionGroup?: any;
+        _transitionGroup?: {
+            name?: string;
+            appear?: boolean;
+            mode?: 'out-in' | 'in-out' | 'default';
+            [key: string]: unknown;
+        };
     };
     children?: VNode[] | string;
 }
 export type VDomRefs = Record<string, HTMLElement | undefined>;
 export interface AnchorBlockVNode extends VNode {
-    tag: "#anchor";
+    tag: '#anchor';
     key: string;
     children: VNode[];
     _startNode?: Comment;
@@ -33,29 +41,29 @@ export interface AnchorBlockVNode extends VNode {
 /**
  * Runtime types
  */
-export type LifecycleKeys = "onConnected" | "onDisconnected" | "onAttributeChanged" | "onError";
+export type LifecycleKeys = 'onConnected' | 'onDisconnected' | 'onAttributeChanged' | 'onError';
 export interface WatchOptions {
     immediate?: boolean;
     deep?: boolean;
 }
-export type WatchCallback<T = any, S = any> = (newValue: T, oldValue: T, context: S) => void;
-export interface WatcherState {
-    callback: WatchCallback<any, any>;
+export type WatchCallback<T = unknown, S = unknown> = (newValue: T, oldValue: T, context: S) => void;
+export interface WatcherState<T = unknown, S = unknown> {
+    callback: WatchCallback<T, S>;
     options: WatchOptions;
-    oldValue: any;
+    oldValue: T;
 }
 export type WatchConfig<S> = {
     [K in keyof S]?: WatchCallback<S[K], S> | [WatchCallback<S[K], S>, WatchOptions?];
-} | Record<string, WatchCallback<any, S> | [WatchCallback<any, S>, WatchOptions?]>;
-type DropLast<T extends any[]> = T extends [...infer Rest, any] ? Rest : T;
+} | Record<string, WatchCallback<unknown, S> | [WatchCallback<unknown, S>, WatchOptions?]>;
+type DropLast<T extends unknown[]> = T extends [...infer Rest, unknown] ? Rest : T;
 type WrapMethod<F> = F extends (...args: infer A) => infer R ? (...args: DropLast<A>) => R : never;
 export type InferMethods<T> = {
-    [K in keyof T as K extends LifecycleKeys ? never : K]: T[K] extends (...args: any[]) => any ? WrapMethod<T[K]> : never;
+    [K in keyof T as K extends LifecycleKeys ? never : K]: T[K] extends (...args: unknown[]) => unknown ? WrapMethod<T[K]> : never;
 };
 export interface Refs {
     refs: Record<string, HTMLElement | undefined>;
 }
-export type ComponentContext<S extends object, C extends object, P extends object, T extends object = {}> = S & C & P & InferMethods<T> & Refs & {
+export type ComponentContext<S extends object, C extends object, P extends object, T extends object = object> = S & C & P & InferMethods<T> & Refs & {
     requestRender?: () => void;
     error?: Error | null;
     hasError?: boolean;
@@ -64,9 +72,11 @@ export type ComponentContext<S extends object, C extends object, P extends objec
      * Dispatch a DOM CustomEvent from the host element.
      * Returns true when the event was not defaultPrevented.
      */
-    emit: <D = any>(eventName: string, detail?: D, options?: CustomEventInit) => boolean;
+    emit: <D = unknown>(eventName: string, detail?: D, options?: CustomEventInit) => boolean;
+} & {
+    [key: string]: unknown;
 };
-export type ComponentConfig<S extends object, C extends object = {}, P extends object = {}, T extends object = {}> = {
+export type ComponentConfig<S extends object, C extends object = object, P extends object = object, T extends object = object> = {
     props?: Record<string, {
         type: StringConstructor | NumberConstructor | BooleanConstructor | FunctionConstructor;
         default?: string | number | boolean;
@@ -77,6 +87,6 @@ export type ComponentConfig<S extends object, C extends object = {}, P extends o
     onAttributeChanged?: (name: string, oldValue: string | null, newValue: string | null, context: ComponentContext<S, C, P, T>) => void;
     onError?: (error: Error | null, context: ComponentContext<S, C, P, T>) => void;
 } & {
-    [K in keyof T as K extends LifecycleKeys ? never : K]: T[K] extends Function ? T[K] : never;
+    [K in keyof T as K extends LifecycleKeys ? never : K]: T[K] extends (...args: unknown[]) => unknown ? T[K] : never;
 };
 export {};

package/dist/runtime/vdom-model-helpers.d.ts

@@ -5,24 +5,24 @@
 /**
  * Check if two values have changed, handling arrays specially
  */
-export declare function hasValueChanged(newValue: any, currentValue: any): boolean;
+export declare function hasValueChanged(newValue: unknown, currentValue: unknown): boolean;
 /**
  * Update state value (reactive or path-based)
  */
-export declare function updateStateValue(isReactive: boolean, value: any, newValue: any, context: any, arg?: string): void;
+export declare function updateStateValue(isReactive: boolean, value: unknown, newValue: unknown, context: Record<string, unknown>, arg?: string): void;
 /**
  * Trigger render and watchers after state update
  */
-export declare function triggerStateUpdate(context: any, isReactive: boolean, value: any, newValue: any): void;
+export declare function triggerStateUpdate(context: Record<string, unknown>, isReactive: boolean, value: unknown, newValue: unknown): void;
 /**
- * Emit custom update events (both kebab-case and camelCase)
+ * Emit custom update events for model binding
  */
-export declare function emitUpdateEvents(target: HTMLElement, propName: string, newValue: any): void;
+export declare function emitUpdateEvents(target: HTMLElement, propName: string, newValue: unknown): void;
 /**
  * Update element properties and attributes to sync with state
  */
-export declare function syncElementWithState(target: any, propName: string, propValue: any, isReactive: boolean): void;
+export declare function syncElementWithState(target: HTMLElement | Record<string, unknown>, propName: string, propValue: unknown, isReactive: boolean): void;
 /**
  * Get current state value (reactive or path-based)
  */
-export declare function getCurrentStateValue(isReactive: boolean, value: any, context: any, arg?: string): any;
+export declare function getCurrentStateValue(isReactive: boolean, value: unknown, context: Record<string, unknown>, arg?: string): unknown;

package/dist/runtime/vdom-ssr.d.ts

@@ -0,0 +1,9 @@
+import type { VNode } from './types';
+/**
+ * Render a VNode to a string (SSR).
+ * Kept intentionally minimal: only serializes attributes under `props.attrs`
+ * to avoid leaking runtime-only values (functions, reactive state, directives).
+ * @param vnode The virtual node to render.
+ * @returns The rendered HTML string.
+ */
+export declare function renderToString(vnode: VNode): string;

package/dist/runtime/vdom.d.ts

@@ -3,7 +3,20 @@
  * Lightweight, strongly typed, functional virtual DOM renderer for custom elements.
  * Features: keyed diffing, incremental patching, focus/caret preservation, event delegation, SSR-friendly, no dependencies.
  */
-import type { VNode, VDomRefs } from "./types";
+import type { VNode, VDomRefs } from './types';
+type PropsMap = Record<string, unknown>;
+type DirectiveSpec = {
+    value: unknown;
+    modifiers: string[];
+    arg?: string;
+};
+type VNodePropBag = {
+    props?: PropsMap;
+    attrs?: PropsMap;
+    directives?: Record<string, DirectiveSpec>;
+    isCustomElement?: boolean;
+    [k: string]: unknown;
+};
 /**
  * Recursively clean up refs and event listeners for all descendants of a node
  * @param node The node to clean up.
@@ -22,7 +35,7 @@ export declare function cleanupRefs(node: Node, refs?: VDomRefs): void;
  * @param el
  * @returns
  */
-export declare function processModelDirective(value: string | any, modifiers: string[], props: Record<string, any>, attrs: Record<string, any>, listeners: Record<string, EventListener>, context?: any, el?: HTMLElement, arg?: string): void;
+export declare function processModelDirective(value: string | unknown, modifiers: string[], props: Record<string, unknown>, attrs: Record<string, unknown>, listeners: Record<string, EventListener>, context?: Record<string, unknown>, el?: HTMLElement, arg?: string): void;
 /**
  * Process :bind directive for attribute/property binding
  * @param value
@@ -31,7 +44,7 @@ export declare function processModelDirective(value: string | any, modifiers: st
  * @param context
  * @returns
  */
-export declare function processBindDirective(value: any, props: Record<string, any>, attrs: Record<string, any>, context?: any, el?: HTMLElement): void;
+export declare function processBindDirective(value: unknown, props: PropsMap, attrs: PropsMap, context?: Record<string, unknown>, el?: HTMLElement): void;
 /**
  * Process :show directive for conditional display
  * @param value
@@ -39,8 +52,8 @@ export declare function processBindDirective(value: any, props: Record<string, a
  * @param context
  * @returns
  */
-export declare function processShowDirective(value: any, attrs: Record<string, any>, context?: any): void;
-export declare function processClassDirective(value: any, attrs: Record<string, any>, context?: any): void;
+export declare function processShowDirective(value: unknown, attrs: Record<string, unknown>, context?: Record<string, unknown>): void;
+export declare function processClassDirective(value: unknown, attrs: Record<string, unknown>, context?: Record<string, unknown>): void;
 /**
  * Process :style directive for dynamic inline styles
  * @param value
@@ -48,7 +61,7 @@ export declare function processClassDirective(value: any, attrs: Record<string,
  * @param context
  * @returns
  */
-export declare function processStyleDirective(value: any, attrs: Record<string, any>, context?: any): void;
+export declare function processStyleDirective(value: unknown, attrs: Record<string, unknown>, context?: Record<string, unknown>): void;
 /**
  * Process :ref directive for element references
  * @param value
@@ -56,7 +69,7 @@ export declare function processStyleDirective(value: any, attrs: Record<string,
  * @param context
  * @returns
  */
-export declare function processRefDirective(value: any, props: Record<string, any>, context?: any): void;
+export declare function processRefDirective(value: unknown, props: Record<string, unknown>, context?: Record<string, unknown>): void;
 /**
  * Process directives and return merged props, attrs, and event listeners
  * @param directives
@@ -66,12 +79,12 @@ export declare function processRefDirective(value: any, props: Record<string, an
  * @returns
  */
 export declare function processDirectives(directives: Record<string, {
-    value: any;
+    value: unknown;
     modifiers: string[];
     arg?: string;
-}>, context?: any, el?: HTMLElement, vnodeAttrs?: Record<string, any>): {
-    props: Record<string, any>;
-    attrs: Record<string, any>;
+}>, context?: Record<string, unknown>, el?: HTMLElement, vnodeAttrs?: PropsMap): {
+    props: Record<string, unknown>;
+    attrs: Record<string, unknown>;
     listeners: Record<string, EventListener>;
 };
 /**
@@ -89,7 +102,7 @@ export declare function assignKeysDeep(nodeOrNodes: VNode | VNode[], baseKey: st
  * @param newProps
  * @param context
  */
-export declare function patchProps(el: HTMLElement, oldProps: Record<string, any>, newProps: Record<string, any>, context?: any): void;
+export declare function patchProps(el: HTMLElement, oldProps: VNodePropBag, newProps: VNodePropBag, context?: Record<string, unknown>): void;
 /**
  * Create a DOM element from a VNode.
  * @param vnode
@@ -97,7 +110,7 @@ export declare function patchProps(el: HTMLElement, oldProps: Record<string, any
  * @param refs
  * @returns
  */
-export declare function createElement(vnode: VNode | string, context?: any, refs?: VDomRefs): Node;
+export declare function createElement(vnode: VNode | string, context?: Record<string, unknown>, refs?: VDomRefs): Node;
 /**
  * Patch children using keys for node matching.
  * @param parent
@@ -107,7 +120,7 @@ export declare function createElement(vnode: VNode | string, context?: any, refs
  * @param refs
  * @returns
  */
-export declare function patchChildren(parent: HTMLElement, oldChildren: VNode[] | string | undefined, newChildren: VNode[] | string | undefined, context?: any, refs?: VDomRefs): void;
+export declare function patchChildren(parent: HTMLElement, oldChildren: VNode[] | string | undefined, newChildren: VNode[] | string | undefined, context?: Record<string, unknown>, refs?: VDomRefs): void;
 /**
  * Patch a node using keys for node matching.
  * @param dom
@@ -117,7 +130,7 @@ export declare function patchChildren(parent: HTMLElement, oldChildren: VNode[]
  * @param refs
  * @returns
  */
-export declare function patch(dom: Node, oldVNode: VNode | string | null, newVNode: VNode | string | null, context?: any, refs?: VDomRefs): Node;
+export declare function patch(dom: Node, oldVNode: VNode | string | null, newVNode: VNode | string | null, context?: Record<string, unknown>, refs?: VDomRefs): Node;
 /**
  * Virtual DOM renderer.
  * @param root The root element to render into.
@@ -125,10 +138,5 @@ export declare function patch(dom: Node, oldVNode: VNode | string | null, newVNo
  * @param context The context to use for rendering.
  * @param refs The refs to use for rendering.
  */
-export declare function vdomRenderer(root: ShadowRoot, vnodeOrArray: VNode | VNode[], context?: any, refs?: VDomRefs): void;
-/**
- * Render a VNode to a string.
- * @param vnode The virtual node to render.
- * @returns The rendered HTML string.
- */
-export declare function renderToString(vnode: VNode): string;
+export declare function vdomRenderer(root: ShadowRoot, vnodeOrArray: VNode | VNode[], context?: Record<string, unknown>, refs?: VDomRefs): void;
+export {};

package/dist/runtime/watchers.d.ts

@@ -1,9 +1,9 @@
-import type { ComponentContext, WatchCallback, WatchOptions, WatcherState } from "./types";
+import type { ComponentContext, WatchCallback, WatchOptions, WatcherState } from './types';
 /**
  * Initializes watchers for a component.
  */
-export declare function initWatchers(context: ComponentContext<any, any, any, any>, watchers: Map<string, WatcherState>, watchConfig: Record<string, WatchCallback | [WatchCallback, WatchOptions]>): void;
+export declare function initWatchers(context: ComponentContext<object, object, object, object>, watchers: Map<string, WatcherState>, watchConfig: Record<string, WatchCallback | [WatchCallback, WatchOptions]>): void;
 /**
  * Triggers watchers when state changes.
  */
-export declare function triggerWatchers(context: ComponentContext<any, any, any, any>, watchers: Map<string, WatcherState>, path: string, newValue: any): void;
+export declare function triggerWatchers(context: ComponentContext<object, object, object, object>, watchers: Map<string, WatcherState>, path: string, newValue: unknown): void;

package/dist/ssr.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SSR entrypoint — small re-export so consumers can import SSR-only helpers
+ * without pulling them into the main client runtime bundle.
+ */
+export { renderToString } from './runtime/vdom-ssr';
+export type { VNode } from './runtime/types';