frontend-hamroun 1.2.85 → 1.2.89

package/dist/jsx-runtime.js

@@ -1,93 +1,104 @@
 function jsx(type, props) {
-  console.log("JSX Transform:", { type, props });
-  const processedProps = { ...props };
-  if (arguments.length > 2) {
-    processedProps.children = Array.prototype.slice.call(arguments, 2);
-  }
-  return { type, props: processedProps };
+    console.log('JSX Transform:', { type, props });
+    const processedProps = { ...props };
+    // Handle children properly
+    if (arguments.length > 2) {
+        processedProps.children = Array.prototype.slice.call(arguments, 2);
+    }
+    return { type, props: processedProps };
 }
 const Fragment = ({ children }) => children;
 async function createElement(vnode) {
-  console.log("Creating element from:", vnode);
-  if (vnode == null) {
-    return document.createTextNode("");
-  }
-  if (typeof vnode === "boolean") {
-    return document.createTextNode("");
-  }
-  if (typeof vnode === "number" || typeof vnode === "string") {
-    return document.createTextNode(String(vnode));
-  }
-  if (Array.isArray(vnode)) {
-    const fragment = document.createDocumentFragment();
-    for (const child of vnode) {
-      const node = await createElement(child);
-      fragment.appendChild(node);
+    console.log('Creating element from:', vnode);
+    // Handle primitives and null
+    if (vnode == null) {
+        return document.createTextNode('');
+    }
+    if (typeof vnode === 'boolean') {
+        return document.createTextNode('');
+    }
+    if (typeof vnode === 'number' || typeof vnode === 'string') {
+        return document.createTextNode(String(vnode));
     }
-    return fragment;
-  }
-  if ("type" in vnode && vnode.props !== void 0) {
-    const { type, props } = vnode;
-    if (typeof type === "function") {
-      try {
-        const result = await type(props || {});
-        const node = await createElement(result);
-        if (node instanceof Element) {
-          node.setAttribute("data-component-id", type.name || type.toString());
+    // Handle arrays
+    if (Array.isArray(vnode)) {
+        const fragment = document.createDocumentFragment();
+        for (const child of vnode) {
+            const node = await createElement(child);
+            fragment.appendChild(node);
         }
-        return node;
-      } catch (error) {
-        console.error("Error rendering component:", error);
-        return document.createTextNode("");
-      }
+        return fragment;
     }
-    const element = document.createElement(type);
-    for (const [key, value] of Object.entries(props || {})) {
-      if (key === "children") continue;
-      if (key.startsWith("on") && typeof value === "function") {
-        const eventName = key.toLowerCase().slice(2);
-        const existingHandler = element.__events?.[eventName];
-        if (existingHandler) {
-          element.removeEventListener(eventName, existingHandler);
+    // Handle VNode
+    if ('type' in vnode && vnode.props !== undefined) {
+        const { type, props } = vnode;
+        // Handle function components
+        if (typeof type === 'function') {
+            try {
+                const result = await type(props || {});
+                const node = await createElement(result);
+                if (node instanceof Element) {
+                    node.setAttribute('data-component-id', type.name || type.toString());
+                }
+                return node;
+            }
+            catch (error) {
+                console.error('Error rendering component:', error);
+                return document.createTextNode('');
+            }
         }
-        element.addEventListener(eventName, value);
-        if (!element.__events) {
-          element.__events = {};
+        // Create DOM element
+        const element = document.createElement(type);
+        // Handle props
+        for (const [key, value] of Object.entries(props || {})) {
+            if (key === 'children')
+                continue;
+            if (key.startsWith('on') && typeof value === 'function') {
+                const eventName = key.toLowerCase().slice(2);
+                // Remove existing event listener if any
+                const existingHandler = element.__events?.[eventName];
+                if (existingHandler) {
+                    element.removeEventListener(eventName, existingHandler);
+                }
+                // Add new event listener
+                element.addEventListener(eventName, value);
+                if (!element.__events) {
+                    element.__events = {};
+                }
+                element.__events[eventName] = value;
+            }
+            else if (key === 'style' && typeof value === 'object') {
+                Object.assign(element.style, value);
+            }
+            else if (key === 'className') {
+                element.setAttribute('class', String(value));
+            }
+            else if (key !== 'key' && key !== 'ref') {
+                element.setAttribute(key, String(value));
+            }
         }
-        element.__events[eventName] = value;
-      } else if (key === "style" && typeof value === "object") {
-        Object.assign(element.style, value);
-      } else if (key === "className") {
-        element.setAttribute("class", String(value));
-      } else if (key !== "key" && key !== "ref") {
-        element.setAttribute(key, String(value));
-      }
-    }
-    const children = props?.children;
-    if (children != null) {
-      const childArray = Array.isArray(children) ? children.flat() : [children];
-      for (const child of childArray) {
-        const childNode = await createElement(child);
-        element.appendChild(childNode);
-      }
+        // Handle children
+        const children = props?.children;
+        if (children != null) {
+            const childArray = Array.isArray(children) ? children.flat() : [children];
+            for (const child of childArray) {
+                const childNode = await createElement(child);
+                element.appendChild(childNode);
+            }
+        }
+        return element;
     }
-    return element;
-  }
-  return document.createTextNode(String(vnode));
+    // Handle other objects by converting to string
+    return document.createTextNode(String(vnode));
 }
+// Named exports object
 const jsxRuntime = {
-  jsx,
-  jsxs: jsx,
-  jsxDEV: jsx,
-  Fragment,
-  createElement
-};
-export {
-  Fragment,
-  createElement,
-  jsxRuntime as default,
-  jsx,
-  jsx as jsxDEV,
-  jsx as jsxs
+    jsx,
+    jsxs: jsx,
+    jsxDEV: jsx,
+    Fragment,
+    createElement
 };
+
+export { Fragment, createElement, jsxRuntime as default, jsx, jsx as jsxDEV, jsx as jsxs };
 //# sourceMappingURL=jsx-runtime.js.map

package/dist/jsx-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"jsx-runtime.js","sources":["../src/jsx-runtime.ts"],"sourcesContent":["import type { VNode, ComponentType, Key, ReactElement } from './types.js';\r\n\r\nfunction jsx(type: string | Function, props: any): VNode {\r\n  console.log('JSX Transform:', { type, props });\r\n  const processedProps = { ...props };\r\n  \r\n  // Handle children properly\r\n  if (arguments.length > 2) {\r\n    processedProps.children = Array.prototype.slice.call(arguments, 2);\r\n  }\r\n  \r\n  return { type, props: processedProps };\r\n}\r\n\r\nconst Fragment = ({ children }: { children: any }) => children;\r\n\r\nasync function createElement(vnode: VNode | any): Promise<Node> {\r\n  console.log('Creating element from:', vnode);\r\n\r\n  // Handle primitives and null\r\n  if (vnode == null) {\r\n    return document.createTextNode('');\r\n  }\r\n  \r\n  if (typeof vnode === 'boolean') {\r\n    return document.createTextNode('');\r\n  }\r\n\r\n  if (typeof vnode === 'number' || typeof vnode === 'string') {\r\n    return document.createTextNode(String(vnode));\r\n  }\r\n\r\n  // Handle arrays\r\n  if (Array.isArray(vnode)) {\r\n    const fragment = document.createDocumentFragment();\r\n    for (const child of vnode) {\r\n      const node = await createElement(child);\r\n      fragment.appendChild(node);\r\n    }\r\n    return fragment;\r\n  }\r\n\r\n  // Handle VNode\r\n  if ('type' in vnode && vnode.props !== undefined) {\r\n    const { type, props } = vnode;\r\n    \r\n    // Handle function components\r\n    if (typeof type === 'function') {\r\n      try {\r\n        const result = await type(props || {});\r\n        const node = await createElement(result);\r\n        if (node instanceof Element) {\r\n          node.setAttribute('data-component-id', type.name || type.toString());\r\n        }\r\n        return node;\r\n      } catch (error) {\r\n        console.error('Error rendering component:', error);\r\n        return document.createTextNode('');\r\n      }\r\n    }\r\n\r\n    // Create DOM element\r\n    const element = document.createElement(type as string);\r\n    \r\n    // Handle props\r\n    for (const [key, value] of Object.entries(props || {})) {\r\n      if (key === 'children') continue;\r\n      if (key.startsWith('on') && typeof value === 'function') {\r\n        const eventName = key.toLowerCase().slice(2);\r\n        // Remove existing event listener if any\r\n        const existingHandler = (element as any).__events?.[eventName];\r\n        if (existingHandler) {\r\n          element.removeEventListener(eventName, existingHandler);\r\n        }\r\n        \r\n        // Add new event listener\r\n        element.addEventListener(eventName, value as EventListener);\r\n        if (!(element as any).__events) {\r\n          (element as any).__events = {};\r\n        }\r\n        (element as any).__events[eventName] = value;\r\n      } else if (key === 'style' && typeof value === 'object') {\r\n        Object.assign(element.style, value);\r\n      } else if (key === 'className') {\r\n        element.setAttribute('class', String(value));\r\n      } else if (key !== 'key' && key !== 'ref') {\r\n        element.setAttribute(key, String(value));\r\n      }\r\n    }\r\n\r\n    // Handle children\r\n    const children = props?.children;\r\n    if (children != null) {\r\n      const childArray = Array.isArray(children) ? children.flat() : [children];\r\n      for (const child of childArray) {\r\n        const childNode = await createElement(child);\r\n        element.appendChild(childNode);\r\n      }\r\n    }\r\n\r\n    return element;\r\n  }\r\n\r\n  // Handle other objects by converting to string\r\n  return document.createTextNode(String(vnode));\r\n}\r\n\r\n// Export named functions and aliases\r\nexport {\r\n  jsx,\r\n  jsx as jsxs,\r\n  jsx as jsxDEV,\r\n  Fragment,\r\n  createElement\r\n};\r\n\r\n// Named exports object\r\nconst jsxRuntime = {\r\n  jsx,\r\n  jsxs: jsx,\r\n  jsxDEV: jsx,\r\n  Fragment,\r\n  createElement\r\n};\r\n\r\nexport default jsxRuntime;\r\n"],"names":[],"mappings":"AAEA,SAAS,IAAI,MAAyB,OAAmB;AACvD,UAAQ,IAAI,kBAAkB,EAAE,MAAM,OAAO;AACvC,QAAA,iBAAiB,EAAE,GAAG,MAAM;AAG9B,MAAA,UAAU,SAAS,GAAG;AACxB,mBAAe,WAAW,MAAM,UAAU,MAAM,KAAK,WAAW,CAAC;AAAA,EAAA;AAG5D,SAAA,EAAE,MAAM,OAAO,eAAe;AACvC;AAEA,MAAM,WAAW,CAAC,EAAE,eAAkC;AAEtD,eAAe,cAAc,OAAmC;AACtD,UAAA,IAAI,0BAA0B,KAAK;AAG3C,MAAI,SAAS,MAAM;AACV,WAAA,SAAS,eAAe,EAAE;AAAA,EAAA;AAG/B,MAAA,OAAO,UAAU,WAAW;AACvB,WAAA,SAAS,eAAe,EAAE;AAAA,EAAA;AAGnC,MAAI,OAAO,UAAU,YAAY,OAAO,UAAU,UAAU;AAC1D,WAAO,SAAS,eAAe,OAAO,KAAK,CAAC;AAAA,EAAA;AAI1C,MAAA,MAAM,QAAQ,KAAK,GAAG;AAClB,UAAA,WAAW,SAAS,uBAAuB;AACjD,eAAW,SAAS,OAAO;AACnB,YAAA,OAAO,MAAM,cAAc,KAAK;AACtC,eAAS,YAAY,IAAI;AAAA,IAAA;AAEpB,WAAA;AAAA,EAAA;AAIT,MAAI,UAAU,SAAS,MAAM,UAAU,QAAW;AAC1C,UAAA,EAAE,MAAM,MAAA,IAAU;AAGpB,QAAA,OAAO,SAAS,YAAY;AAC1B,UAAA;AACF,cAAM,SAAS,MAAM,KAAK,SAAS,CAAA,CAAE;AAC/B,cAAA,OAAO,MAAM,cAAc,MAAM;AACvC,YAAI,gBAAgB,SAAS;AAC3B,eAAK,aAAa,qBAAqB,KAAK,QAAQ,KAAK,UAAU;AAAA,QAAA;AAE9D,eAAA;AAAA,eACA,OAAO;AACN,gBAAA,MAAM,8BAA8B,KAAK;AAC1C,eAAA,SAAS,eAAe,EAAE;AAAA,MAAA;AAAA,IACnC;AAII,UAAA,UAAU,SAAS,cAAc,IAAc;AAG1C,eAAA,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,SAAS,CAAA,CAAE,GAAG;AACtD,UAAI,QAAQ,WAAY;AACxB,UAAI,IAAI,WAAW,IAAI,KAAK,OAAO,UAAU,YAAY;AACvD,cAAM,YAAY,IAAI,YAAY,EAAE,MAAM,CAAC;AAErC,cAAA,kBAAmB,QAAgB,WAAW,SAAS;AAC7D,YAAI,iBAAiB;AACX,kBAAA,oBAAoB,WAAW,eAAe;AAAA,QAAA;AAIhD,gBAAA,iBAAiB,WAAW,KAAsB;AACtD,YAAA,CAAE,QAAgB,UAAU;AAC7B,kBAAgB,WAAW,CAAC;AAAA,QAAA;AAE9B,gBAAgB,SAAS,SAAS,IAAI;AAAA,MAC9B,WAAA,QAAQ,WAAW,OAAO,UAAU,UAAU;AAChD,eAAA,OAAO,QAAQ,OAAO,KAAK;AAAA,MAAA,WACzB,QAAQ,aAAa;AAC9B,gBAAQ,aAAa,SAAS,OAAO,KAAK,CAAC;AAAA,MAClC,WAAA,QAAQ,SAAS,QAAQ,OAAO;AACzC,gBAAQ,aAAa,KAAK,OAAO,KAAK,CAAC;AAAA,MAAA;AAAA,IACzC;AAIF,UAAM,WAAW,OAAO;AACxB,QAAI,YAAY,MAAM;AACd,YAAA,aAAa,MAAM,QAAQ,QAAQ,IAAI,SAAS,SAAS,CAAC,QAAQ;AACxE,iBAAW,SAAS,YAAY;AACxB,cAAA,YAAY,MAAM,cAAc,KAAK;AAC3C,gBAAQ,YAAY,SAAS;AAAA,MAAA;AAAA,IAC/B;AAGK,WAAA;AAAA,EAAA;AAIT,SAAO,SAAS,eAAe,OAAO,KAAK,CAAC;AAC9C;AAYA,MAAM,aAAa;AAAA,EACjB;AAAA,EACA,MAAM;AAAA,EACN,QAAQ;AAAA,EACR;AAAA,EACA;AACF;"}
+{"version":3,"file":"jsx-runtime.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/lifecycle-events.d.ts

@@ -0,0 +1,109 @@
+export declare enum LifecycleEvents {
+    APP_INIT = "app:init",
+    APP_MOUNTED = "app:mounted",
+    APP_UPDATED = "app:updated",
+    APP_ERROR = "app:error",
+    APP_DESTROYED = "app:destroyed",
+    COMPONENT_CREATED = "component:created",
+    COMPONENT_MOUNTED = "component:mounted",
+    COMPONENT_UPDATED = "component:updated",
+    COMPONENT_ERROR = "component:error",
+    COMPONENT_UNMOUNTED = "component:unmounted",
+    ROUTER_BEFORE_CHANGE = "router:before-change",
+    ROUTER_AFTER_CHANGE = "router:after-change",
+    ROUTER_ERROR = "router:error",
+    STORE_INITIALIZED = "store:initialized",
+    STORE_BEFORE_ACTION = "store:before-action",
+    STORE_AFTER_ACTION = "store:after-action",
+    STORE_ERROR = "store:error"
+}
+export interface ComponentInfo {
+    id: string;
+    name: string;
+    props: Record<string, any>;
+    path?: string;
+}
+export interface RouteChangeInfo {
+    from: string;
+    to: string;
+    params: Record<string, string>;
+}
+export interface StoreActionInfo {
+    type: string;
+    payload: any;
+    prevState: any;
+    nextState: any;
+}
+export declare function emitAppInit(data: any): void;
+export declare function emitAppMounted(rootElement: HTMLElement): void;
+export declare function emitAppUpdated(): void;
+export declare function emitAppError(error: Error): void;
+export declare function emitAppDestroyed(): void;
+export declare function emitComponentCreated(info: ComponentInfo): void;
+export declare function emitComponentMounted(info: ComponentInfo, element: HTMLElement): void;
+export declare function emitComponentUpdated(info: ComponentInfo, prevProps: Record<string, any>, newProps: Record<string, any>): void;
+export declare function emitComponentError(info: ComponentInfo, error: Error): void;
+export declare function emitComponentUnmounted(info: ComponentInfo): void;
+export declare function emitRouterBeforeChange(info: RouteChangeInfo): Promise<boolean>;
+export declare function emitRouterAfterChange(info: RouteChangeInfo): void;
+export declare function emitRouterError(error: Error, info?: Partial<RouteChangeInfo>): void;
+export declare function emitStoreInitialized(state: any): void;
+export declare function emitStoreBeforeAction(actionType: string, payload: any, state: any): void;
+export declare function emitStoreAfterAction(info: StoreActionInfo): void;
+export declare function emitStoreError(error: Error, actionType: string, payload: any): void;
+export declare function onAppInit(handler: (data: any) => void): () => void;
+export declare function onAppMounted(handler: (rootElement: HTMLElement) => void): () => void;
+export declare function onAppUpdated(handler: () => void): () => void;
+export declare function onAppError(handler: (error: Error) => void): () => void;
+export declare function onAppDestroyed(handler: () => void): () => void;
+export declare function onComponentCreated(handler: (info: ComponentInfo) => void): () => void;
+export declare function onComponentMounted(handler: (info: ComponentInfo, element: HTMLElement) => void): () => void;
+export declare function onComponentUpdated(handler: (info: ComponentInfo, prevProps: Record<string, any>, newProps: Record<string, any>) => void): () => void;
+export declare function onComponentError(handler: (info: ComponentInfo, error: Error) => void): () => void;
+export declare function onComponentUnmounted(handler: (info: ComponentInfo) => void): () => void;
+export declare function onRouterBeforeChange(handler: (info: RouteChangeInfo, prevent: () => void) => void): () => void;
+export declare function onRouterAfterChange(handler: (info: RouteChangeInfo) => void): () => void;
+export declare function onRouterError(handler: (error: Error, info?: Partial<RouteChangeInfo>) => void): () => void;
+export declare function onStoreInitialized(handler: (state: any) => void): () => void;
+export declare function onStoreBeforeAction(handler: (actionType: string, payload: any, state: any) => void): () => void;
+export declare function onStoreAfterAction(handler: (info: StoreActionInfo) => void): () => void;
+export declare function onStoreError(handler: (error: Error, actionType: string, payload: any) => void): () => void;
+declare const _default: {
+    LifecycleEvents: typeof LifecycleEvents;
+    emitAppInit: typeof emitAppInit;
+    emitAppMounted: typeof emitAppMounted;
+    emitAppUpdated: typeof emitAppUpdated;
+    emitAppError: typeof emitAppError;
+    emitAppDestroyed: typeof emitAppDestroyed;
+    emitComponentCreated: typeof emitComponentCreated;
+    emitComponentMounted: typeof emitComponentMounted;
+    emitComponentUpdated: typeof emitComponentUpdated;
+    emitComponentError: typeof emitComponentError;
+    emitComponentUnmounted: typeof emitComponentUnmounted;
+    emitRouterBeforeChange: typeof emitRouterBeforeChange;
+    emitRouterAfterChange: typeof emitRouterAfterChange;
+    emitRouterError: typeof emitRouterError;
+    emitStoreInitialized: typeof emitStoreInitialized;
+    emitStoreBeforeAction: typeof emitStoreBeforeAction;
+    emitStoreAfterAction: typeof emitStoreAfterAction;
+    emitStoreError: typeof emitStoreError;
+    onAppInit: typeof onAppInit;
+    onAppMounted: typeof onAppMounted;
+    onAppUpdated: typeof onAppUpdated;
+    onAppError: typeof onAppError;
+    onAppDestroyed: typeof onAppDestroyed;
+    onComponentCreated: typeof onComponentCreated;
+    onComponentMounted: typeof onComponentMounted;
+    onComponentUpdated: typeof onComponentUpdated;
+    onComponentError: typeof onComponentError;
+    onComponentUnmounted: typeof onComponentUnmounted;
+    onRouterBeforeChange: typeof onRouterBeforeChange;
+    onRouterAfterChange: typeof onRouterAfterChange;
+    onRouterError: typeof onRouterError;
+    onStoreInitialized: typeof onStoreInitialized;
+    onStoreBeforeAction: typeof onStoreBeforeAction;
+    onStoreAfterAction: typeof onStoreAfterAction;
+    onStoreError: typeof onStoreError;
+};
+export default _default;
+//# sourceMappingURL=lifecycle-events.d.ts.map

package/dist/lifecycle-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-events.d.ts","sourceRoot":"","sources":["../src/lifecycle-events.ts"],"names":[],"mappings":"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"}

package/dist/lifecycle-events.js

@@ -0,0 +1,176 @@
+/**
+ * Lifecycle events for components and application
+ */
+import { eventBus } from './event-bus.js';
+export var LifecycleEvents;
+(function (LifecycleEvents) {
+    LifecycleEvents["APP_INIT"] = "app:init";
+    LifecycleEvents["APP_MOUNTED"] = "app:mounted";
+    LifecycleEvents["APP_UPDATED"] = "app:updated";
+    LifecycleEvents["APP_ERROR"] = "app:error";
+    LifecycleEvents["APP_DESTROYED"] = "app:destroyed";
+    LifecycleEvents["COMPONENT_CREATED"] = "component:created";
+    LifecycleEvents["COMPONENT_MOUNTED"] = "component:mounted";
+    LifecycleEvents["COMPONENT_UPDATED"] = "component:updated";
+    LifecycleEvents["COMPONENT_ERROR"] = "component:error";
+    LifecycleEvents["COMPONENT_UNMOUNTED"] = "component:unmounted";
+    LifecycleEvents["ROUTER_BEFORE_CHANGE"] = "router:before-change";
+    LifecycleEvents["ROUTER_AFTER_CHANGE"] = "router:after-change";
+    LifecycleEvents["ROUTER_ERROR"] = "router:error";
+    LifecycleEvents["STORE_INITIALIZED"] = "store:initialized";
+    LifecycleEvents["STORE_BEFORE_ACTION"] = "store:before-action";
+    LifecycleEvents["STORE_AFTER_ACTION"] = "store:after-action";
+    LifecycleEvents["STORE_ERROR"] = "store:error";
+})(LifecycleEvents || (LifecycleEvents = {}));
+// Event emitters
+export function emitAppInit(data) {
+    eventBus.emit(LifecycleEvents.APP_INIT, data);
+}
+export function emitAppMounted(rootElement) {
+    eventBus.emit(LifecycleEvents.APP_MOUNTED, rootElement);
+}
+export function emitAppUpdated() {
+    eventBus.emit(LifecycleEvents.APP_UPDATED);
+}
+export function emitAppError(error) {
+    eventBus.emit(LifecycleEvents.APP_ERROR, error);
+}
+export function emitAppDestroyed() {
+    eventBus.emit(LifecycleEvents.APP_DESTROYED);
+}
+export function emitComponentCreated(info) {
+    eventBus.emit(LifecycleEvents.COMPONENT_CREATED, info);
+}
+export function emitComponentMounted(info, element) {
+    eventBus.emit(LifecycleEvents.COMPONENT_MOUNTED, info, element);
+}
+export function emitComponentUpdated(info, prevProps, newProps) {
+    eventBus.emit(LifecycleEvents.COMPONENT_UPDATED, info, prevProps, newProps);
+}
+export function emitComponentError(info, error) {
+    eventBus.emit(LifecycleEvents.COMPONENT_ERROR, info, error);
+}
+export function emitComponentUnmounted(info) {
+    eventBus.emit(LifecycleEvents.COMPONENT_UNMOUNTED, info);
+}
+export function emitRouterBeforeChange(info) {
+    return new Promise(resolve => {
+        // Allow hooks to prevent navigation
+        let prevented = false;
+        const prevent = () => {
+            prevented = true;
+        };
+        eventBus.emit(LifecycleEvents.ROUTER_BEFORE_CHANGE, info, prevent);
+        // Resolve with whether navigation should continue
+        resolve(!prevented);
+    });
+}
+export function emitRouterAfterChange(info) {
+    eventBus.emit(LifecycleEvents.ROUTER_AFTER_CHANGE, info);
+}
+export function emitRouterError(error, info) {
+    eventBus.emit(LifecycleEvents.ROUTER_ERROR, error, info);
+}
+export function emitStoreInitialized(state) {
+    eventBus.emit(LifecycleEvents.STORE_INITIALIZED, state);
+}
+export function emitStoreBeforeAction(actionType, payload, state) {
+    eventBus.emit(LifecycleEvents.STORE_BEFORE_ACTION, actionType, payload, state);
+}
+export function emitStoreAfterAction(info) {
+    eventBus.emit(LifecycleEvents.STORE_AFTER_ACTION, info);
+}
+export function emitStoreError(error, actionType, payload) {
+    eventBus.emit(LifecycleEvents.STORE_ERROR, error, actionType, payload);
+}
+// Event listeners
+export function onAppInit(handler) {
+    return eventBus.on(LifecycleEvents.APP_INIT, handler);
+}
+export function onAppMounted(handler) {
+    return eventBus.on(LifecycleEvents.APP_MOUNTED, handler);
+}
+export function onAppUpdated(handler) {
+    return eventBus.on(LifecycleEvents.APP_UPDATED, handler);
+}
+export function onAppError(handler) {
+    return eventBus.on(LifecycleEvents.APP_ERROR, handler);
+}
+export function onAppDestroyed(handler) {
+    return eventBus.on(LifecycleEvents.APP_DESTROYED, handler);
+}
+export function onComponentCreated(handler) {
+    return eventBus.on(LifecycleEvents.COMPONENT_CREATED, handler);
+}
+export function onComponentMounted(handler) {
+    return eventBus.on(LifecycleEvents.COMPONENT_MOUNTED, handler);
+}
+export function onComponentUpdated(handler) {
+    return eventBus.on(LifecycleEvents.COMPONENT_UPDATED, handler);
+}
+export function onComponentError(handler) {
+    return eventBus.on(LifecycleEvents.COMPONENT_ERROR, handler);
+}
+export function onComponentUnmounted(handler) {
+    return eventBus.on(LifecycleEvents.COMPONENT_UNMOUNTED, handler);
+}
+export function onRouterBeforeChange(handler) {
+    return eventBus.on(LifecycleEvents.ROUTER_BEFORE_CHANGE, handler);
+}
+export function onRouterAfterChange(handler) {
+    return eventBus.on(LifecycleEvents.ROUTER_AFTER_CHANGE, handler);
+}
+export function onRouterError(handler) {
+    return eventBus.on(LifecycleEvents.ROUTER_ERROR, handler);
+}
+export function onStoreInitialized(handler) {
+    return eventBus.on(LifecycleEvents.STORE_INITIALIZED, handler);
+}
+export function onStoreBeforeAction(handler) {
+    return eventBus.on(LifecycleEvents.STORE_BEFORE_ACTION, handler);
+}
+export function onStoreAfterAction(handler) {
+    return eventBus.on(LifecycleEvents.STORE_AFTER_ACTION, handler);
+}
+export function onStoreError(handler) {
+    return eventBus.on(LifecycleEvents.STORE_ERROR, handler);
+}
+export default {
+    LifecycleEvents,
+    // Emitters
+    emitAppInit,
+    emitAppMounted,
+    emitAppUpdated,
+    emitAppError,
+    emitAppDestroyed,
+    emitComponentCreated,
+    emitComponentMounted,
+    emitComponentUpdated,
+    emitComponentError,
+    emitComponentUnmounted,
+    emitRouterBeforeChange,
+    emitRouterAfterChange,
+    emitRouterError,
+    emitStoreInitialized,
+    emitStoreBeforeAction,
+    emitStoreAfterAction,
+    emitStoreError,
+    // Listeners
+    onAppInit,
+    onAppMounted,
+    onAppUpdated,
+    onAppError,
+    onAppDestroyed,
+    onComponentCreated,
+    onComponentMounted,
+    onComponentUpdated,
+    onComponentError,
+    onComponentUnmounted,
+    onRouterBeforeChange,
+    onRouterAfterChange,
+    onRouterError,
+    onStoreInitialized,
+    onStoreBeforeAction,
+    onStoreAfterAction,
+    onStoreError
+};

package/dist/renderComponent.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Result of component rendering
+ */
+export interface RenderResult {
+    html: string;
+    success: boolean;
+    error?: Error;
+}
+/**
+ * Renders a component to an HTML string with error handling
+ */
+export declare function renderComponent(Component: any, props?: any): Promise<RenderResult>;
+export default renderComponent;
+//# sourceMappingURL=renderComponent.d.ts.map

package/dist/renderComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderComponent.d.ts","sourceRoot":"","sources":["../src/renderComponent.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,GAAE,GAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAqB5F;AAED,eAAe,eAAe,CAAC"}

package/dist/renderComponent.js

@@ -0,0 +1,29 @@
+/**
+ * Utility for rendering components to strings and hydrating them
+ */
+import { renderToString } from './server-renderer.js';
+/**
+ * Renders a component to an HTML string with error handling
+ */
+export async function renderComponent(Component, props = {}) {
+    try {
+        // Call the component function with props
+        const element = Component(props);
+        // Convert the element to an HTML string
+        const html = await renderToString(element);
+        return {
+            html,
+            success: true
+        };
+    }
+    catch (error) {
+        console.error('Error rendering component:', error);
+        return {
+            html: `<div class="error">Error rendering component</div>`,
+            success: false,
+            // Fix the type error by ensuring error is an Error object
+            error: error instanceof Error ? error : new Error(String(error))
+        };
+    }
+}
+export default renderComponent;

package/dist/renderer.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement } from './types.js';
+export declare function render(element: ReactElement, container: Element | DocumentFragment): Promise<void>;
+export declare function hydrate(element: ReactElement, container: Element): Promise<void>;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,wBAAsB,MAAM,CAAC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,GAAG,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCxG;AAGD,wBAAsB,OAAO,CAAC,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CActF"}

package/dist/renderer.js

@@ -0,0 +1,49 @@
+import { createElement } from './jsx-runtime.js';
+import { prepareRender, finishRender, setRenderCallback } from './hooks.js';
+// Render function for client-side rendering
+export async function render(element, container) {
+    try {
+        // Set up render callback for state updates
+        setRenderCallback(render, element, container);
+        // Prepare render context
+        const renderId = prepareRender(element);
+        // Create DOM nodes from virtual elements
+        const domNode = await createElement(element);
+        // Clear container and append new content
+        // Handle both Element and DocumentFragment cases
+        if (container instanceof Element) {
+            container.innerHTML = '';
+        }
+        else {
+            // For DocumentFragment, clear all children
+            while (container.firstChild) {
+                container.removeChild(container.firstChild);
+            }
+        }
+        container.appendChild(domNode);
+        // Finish render
+        finishRender();
+        console.log('Render completed successfully');
+    }
+    catch (error) {
+        console.error('Error during render:', error);
+        // Clean up render context on error
+        finishRender();
+        throw error;
+    }
+}
+// Hydrate function for client-side hydration of SSR content
+export async function hydrate(element, container) {
+    try {
+        console.log('Starting hydration...');
+        // For now, hydrate works the same as render
+        // In a more advanced implementation, this would preserve existing DOM
+        // and only attach event listeners and initialize state
+        await render(element, container);
+        console.log('Hydration completed successfully');
+    }
+    catch (error) {
+        console.error('Error during hydration:', error);
+        throw error;
+    }
+}

package/dist/router.d.ts

@@ -0,0 +1,56 @@
+export interface Route {
+    path: string;
+    component: any;
+    exact?: boolean;
+    children?: Route[];
+}
+export interface RouterContextValue {
+    currentPath: string;
+    navigate: (path: string) => void;
+    params: Record<string, string>;
+    query: Record<string, string>;
+}
+export interface RouteParams {
+    [key: string]: string;
+}
+export declare const RouterContext: import("./types.js").Context<RouterContextValue>;
+export declare function useRouter(): RouterContextValue;
+export declare function useLocation(): {
+    pathname: string;
+    search: string;
+    hash: string;
+    state: {};
+};
+export declare function useParams<T extends RouteParams = RouteParams>(): T;
+export declare function useNavigate(): (path: string) => void;
+export declare function RouterProvider({ children }: {
+    children: any;
+}): any;
+export declare function Router({ routes }: {
+    routes: Route[];
+}): any;
+export declare function Link({ to, children, ...rest }: {
+    to: string;
+    children: any;
+    [key: string]: any;
+}): any;
+export declare function Route({ path, component }: {
+    path: string;
+    component: any;
+}): null;
+export declare function Switch({ children }: {
+    children: any;
+}): any;
+declare const _default: {
+    RouterProvider: typeof RouterProvider;
+    Router: typeof Router;
+    Link: typeof Link;
+    Route: typeof Route;
+    Switch: typeof Switch;
+    useRouter: typeof useRouter;
+    useParams: typeof useParams;
+    useNavigate: typeof useNavigate;
+    useLocation: typeof useLocation;
+};
+export default _default;
+//# sourceMappingURL=router.d.ts.map