@jasonshimmy/custom-elements-runtime 0.3.0 → 1.0.0

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

@@ -0,0 +1,30 @@
+/**
+ * Secure expression evaluator to replace unsafe Function() constructor
+ * Provides AST-based validation and caching for performance
+ */
+/**
+ * Secure expression evaluator with caching and AST validation
+ */
+declare class SecureExpressionEvaluator {
+    private static cache;
+    private static maxCacheSize;
+    private static dangerousPatterns;
+    static evaluate(expression: string, context: any): any;
+    private static createEvaluator;
+    private static hasDangerousPatterns;
+    private static createSafeEvaluator;
+    private static createObjectEvaluator;
+    private static parseObjectProperties;
+    private static createSimpleEvaluator;
+    /**
+     * Evaluate a very small, safe expression grammar without using eval/Function.
+     * Supports: numbers, string literals, true/false, null, arrays, unary !,
+     * arithmetic (+ - * / %), comparisons, logical && and ||, parentheses, and ternary `a ? b : c`.
+     */
+    private static evaluateBasicExpression;
+    private static tokenize;
+    private static evaluateSimpleValue;
+    static clearCache(): void;
+    static getCacheSize(): number;
+}
+export { SecureExpressionEvaluator };

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

@@ -23,6 +23,10 @@ export declare function parseProps(str: string, values?: unknown[], context?: Re
  *  - 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[];
+/**
+ * Clear the template compile cache (useful for tests)
+ */
+export declare function clearTemplateCompileCache(): void;
 /**
  * Default export: plain html.
  */

package/dist/runtime/types.d.ts

@@ -14,6 +14,7 @@ export interface VNode {
             arg?: string;
         }>;
         ref?: string;
+        reactiveRef?: any;
         /** Compiler-provided hint: whether this VNode represents a custom element (contains a dash) */
         isCustomElement?: boolean;
     };
@@ -30,7 +31,7 @@ export interface AnchorBlockVNode extends VNode {
 /**
  * Runtime types
  */
-export type LifecycleKeys = "onConnected" | "onDisconnected" | "onAttributeChanged" | "onError" | "errorFallback";
+export type LifecycleKeys = "onConnected" | "onDisconnected" | "onAttributeChanged" | "onError";
 export interface WatchOptions {
     immediate?: boolean;
     deep?: boolean;
@@ -64,24 +65,15 @@ export type ComponentContext<S extends object, C extends object, P extends objec
     emit: <D = any>(eventName: string, detail?: D, options?: CustomEventInit) => boolean;
 };
 export type ComponentConfig<S extends object, C extends object = {}, P extends object = {}, T extends object = {}> = {
-    state?: S;
-    computed?: {
-        [K in keyof C]: (context: ComponentContext<S, C, P, T>) => C[K];
-    };
     props?: Record<string, {
         type: StringConstructor | NumberConstructor | BooleanConstructor | FunctionConstructor;
         default?: string | number | boolean;
     }>;
-    watch?: WatchConfig<ComponentContext<S, C, P, T>>;
-    style?: string | ((context: ComponentContext<S, C, P, T>) => string);
     render: (context: ComponentContext<S, C, P, T>) => VNode | VNode[] | Promise<VNode | VNode[]>;
-    loadingTemplate?: (context: ComponentContext<S, C, P, T>) => VNode | VNode[];
-    errorTemplate?: (error: Error, context: ComponentContext<S, C, P, T>) => VNode | VNode[];
     onConnected?: (context: ComponentContext<S, C, P, T>) => void;
     onDisconnected?: (context: ComponentContext<S, C, P, T>) => void;
     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;
-    errorFallback?: (error: Error | null, context: ComponentContext<S, C, P, T>) => string;
 } & {
     [K in keyof T as K extends LifecycleKeys ? never : K]: T[K] extends Function ? T[K] : never;
 };

package/dist/runtime/vdom.d.ts

@@ -5,7 +5,7 @@
  */
 import type { VNode, VDomRefs } from "./types";
 /**
- * Recursively clean up refs for all descendants of a node
+ * Recursively clean up refs and event listeners for all descendants of a node
  * @param node The node to clean up.
  * @param refs The refs to clean up.
  * @returns
@@ -22,7 +22,7 @@ export declare function cleanupRefs(node: Node, refs?: VDomRefs): void;
  * @param el
  * @returns
  */
-export declare function processModelDirective(value: string, 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 | any, modifiers: string[], props: Record<string, any>, attrs: Record<string, any>, listeners: Record<string, EventListener>, context?: any, el?: HTMLElement, arg?: string): void;
 /**
  * Process :bind directive for attribute/property binding
  * @param value
@@ -31,7 +31,7 @@ export declare function processModelDirective(value: string, modifiers: string[]
  * @param context
  * @returns
  */
-export declare function processBindDirective(value: string, props: Record<string, any>, attrs: Record<string, any>, context?: any): void;
+export declare function processBindDirective(value: any, props: Record<string, any>, attrs: Record<string, any>, context?: any): void;
 /**
  * Process :show directive for conditional display
  * @param value
@@ -39,23 +39,24 @@ export declare function processBindDirective(value: string, props: Record<string
  * @param context
  * @returns
  */
-export declare function processShowDirective(value: string, attrs: Record<string, any>, context?: any): void;
+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;
 /**
- * Process :class directive for conditional CSS classes
+ * Process :style directive for dynamic inline styles
  * @param value
  * @param attrs
  * @param context
  * @returns
  */
-export declare function processClassDirective(value: string, attrs: Record<string, any>, context?: any): void;
+export declare function processStyleDirective(value: any, attrs: Record<string, any>, context?: any): void;
 /**
- * Process :style directive for dynamic inline styles
+ * Process :ref directive for element references
  * @param value
- * @param attrs
+ * @param props
  * @param context
  * @returns
  */
-export declare function processStyleDirective(value: any, attrs: Record<string, any>, context?: any): void;
+export declare function processRefDirective(value: any, props: Record<string, any>, context?: any): void;
 /**
  * Process directives and return merged props, attrs, and event listeners
  * @param directives

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jasonshimmy/custom-elements-runtime",
   "description": "A powerful, modern, and lightweight runtime for creating reactive web components with TypeScript",
-  "version": "0.3.0",
+  "version": "1.0.0",
   "type": "module",
   "keywords": [
     "web-components",