frontend-hamroun 1.2.15 → 1.2.17

package/src/index.ts

@@ -1,144 +0,0 @@
-// Frontend exports
-import { jsx, jsxs, jsxDEV, createElement, Fragment } from './jsx-runtime/index';
-import { Component } from './component';
-import { useState, useEffect, useRef, useMemo, useErrorBoundary } from './hooks';
-import { render, hydrate } from './renderer';
-import { renderToString } from './server-renderer';
-import { prepareRender, finishRender } from './hooks';
-import { batchUpdates } from './batch';
-import { createContext, useContext } from './context';
-
-// Import backend functionality
-import { createServer } from './backend/server';
-import { createAuth } from './backend/auth';
-import { createModel, FieldTypes } from './backend/model';
-import { createModelRouter, createApiRouter as createCustomRouter } from './backend/router';
-import { 
-  sendSuccess, 
-  sendError, 
-  apiResponse, 
-  getPaginationParams, 
-  paginationMiddleware,
-  validateRequest,
-  asyncHandler,
-  createRestEndpoints,
-  createApiRouter
-} from './backend/api-utils';
-import { DatabaseConnector } from './backend/database';
-
-// Export JSX runtime
-export {
-  jsx,
-  jsxs,
-  jsxDEV, // Add jsxDEV export
-  createElement,
-  Fragment
-};
-
-// Export hooks
-export {
-  useState,
-  useEffect,
-  useRef,
-  useMemo,
-  useErrorBoundary,
-  prepareRender,
-  finishRender,
-  batchUpdates,
-  createContext,
-  useContext
-};
-
-// Export component base class
-export { Component };
-
-// Export renderers
-export {
-  render,
-  hydrate,
-  renderToString
-};
-
-// Export backend functionality
-export {
-  createServer,
-  createAuth,
-  createModel,
-  FieldTypes,
-  createModelRouter,
-  createCustomRouter,
-  createApiRouter,
-  sendSuccess, 
-  sendError, 
-  apiResponse, 
-  getPaginationParams,
-  paginationMiddleware,
-  validateRequest,
-  asyncHandler,
-  createRestEndpoints,
-  DatabaseConnector
-};
-
-// Re-export types
-export type { Context } from './context';
-export type { VNode } from './types';
-
-// Backend types
-export type {
-  HamrounServerOptions,
-  RouterOptions,
-  RouteContext,
-  PaginationOptions,
-  PaginatedResult,
-  DatabaseOptions,
-  Model,
-  ApiResponse
-} from './backend/types';
-
-export type {
-  AuthOptions,
-  TokenPair
-} from './backend/auth';
-
-// Default export with all functionality
-export default {
-  // Frontend
-  jsx,
-  jsxs,
-  jsxDEV, // Add to default export
-  createElement,
-  Fragment,
-  Component,
-  useState,
-  useEffect,
-  useRef,
-  useMemo,
-  useErrorBoundary,
-  render,
-  hydrate,
-  renderToString,
-  prepareRender,
-  finishRender,
-  batchUpdates,
-  createContext,
-  useContext,
-  
-  // Backend
-  createServer,
-  createAuth,
-  createModel,
-  FieldTypes,
-  createModelRouter,
-  createCustomRouter,
-  createApiRouter,
-  sendSuccess,
-  sendError,
-  apiResponse,
-  getPaginationParams,
-  paginationMiddleware,
-  validateRequest,
-  asyncHandler,
-  createRestEndpoints,
-  DatabaseConnector
-};
-

package/src/jsx-runtime/index.ts

@@ -1,27 +0,0 @@
-import { jsx, jsxs, createElement, Fragment, jsxDEV } from './jsx-runtime';
-
-export {
-  jsx,
-  jsxs,
-  jsxDEV, // Add export for jsxDEV
-  createElement,
-  Fragment
-};
-
-// For global access in browsers
-if (typeof window !== 'undefined') {
-  // TypeScript safe way to add properties to window
-  (window as any).jsx = jsx;
-  (window as any).jsxs = jsxs;
-  (window as any).jsxDEV = jsxDEV; // Add jsxDEV
-  (window as any).Fragment = Fragment;
-}
-
-// Default export for module usage
-export default {
-  jsx,
-  jsxs,
-  jsxDEV,
-  createElement,
-  Fragment
-};

package/src/jsx-runtime/jsx-runtime.ts

@@ -1,104 +0,0 @@
-import { diff } from '../vdom';
-
-// Create a safe global object reference that works in both browser and Node
-const globalObj: any = typeof window !== 'undefined' ? window : 
-                      typeof global !== 'undefined' ? global : {};
-
-export function jsx(type: string | Function, props: any, key?: string): any {
-  return {
-    type,
-    props: props || {},
-    key
-  };
-}
-
-// Use the jsx function for jsxs as well
-export function jsxs(type: string | Function, props: any, key?: string): any {
-  return jsx(type, props, key);
-}
-
-export function createElement(vnode: any): HTMLElement | Text {
-  if (typeof vnode === 'string' || typeof vnode === 'number') {
-    return document.createTextNode(String(vnode));
-  }
-
-  if (typeof vnode.type === 'function') {
-    const result = vnode.type(vnode.props);
-    return createElement(result);
-  }
-
-  const element = document.createElement(vnode.type);
-  
-  Object.entries(vnode.props || {}).forEach(([name, value]: [string, any]) => {
-    if (name === 'children') {
-      const children = Array.isArray(value) ? value : [value];
-      children.forEach((child: any) => {
-        if (child != null) {
-          const childElement = createElement(child);
-          // Generate stats for testing
-          if (process.env.NODE_ENV === 'test' && typeof window !== 'undefined') {
-            // Create stats tracking
-            if (!globalObj.__renderStats) {
-              globalObj.__renderStats = {
-                elementsCreated: 0,
-                textNodesCreated: 0,
-                eventsAttached: 0,
-                renderTime: 0
-              };
-              
-              // Write stats to file when tests complete
-              if (typeof afterAll === 'function') {
-                afterAll(() => {
-                  try {
-                    const fs = require('fs');
-                    const path = require('path');
-                    const statsPath = path.resolve(process.cwd(), 'jsx-runtime-stats.json');
-                    fs.writeFileSync(statsPath, JSON.stringify(globalObj.__renderStats, null, 2));
-                    console.log(`JSX runtime stats written to ${statsPath}`);
-                  } catch (error) {
-                    console.error('Failed to write stats file:', error);
-                  }
-                });
-              }
-            }
-            
-            // Increment stats based on element type
-            if (childElement instanceof Text) {
-              globalObj.__renderStats.textNodesCreated++;
-            } else {
-              globalObj.__renderStats.elementsCreated++;
-            }
-          }
-          
-          element.appendChild(childElement);
-        }
-      });
-    } else if (name.startsWith('on')) {
-      const eventName = name.toLowerCase().substring(2);
-      element.addEventListener(eventName, value);
-      
-      // Track event attachment in stats
-      if (process.env.NODE_ENV === 'test' && typeof window !== 'undefined' && globalObj.__renderStats) {
-        globalObj.__renderStats.eventsAttached++;
-      }
-    } else if (name === 'className') {
-      // Handle className specially by setting it as the class attribute
-      element.setAttribute('class', value);
-    } else if (name === 'style' && typeof value === 'object') {
-      // Handle style objects by merging them into element.style
-      Object.entries(value).forEach(([styleProp, styleValue]) => {
-        element.style[styleProp as any] = String(styleValue);
-      });
-    } else {
-      element.setAttribute(name, value);
-    }
-  });
-
-  return element;
-}
-
-export const Fragment = Symbol('Fragment');
-
-// Add named exports for React JSX compatibility
-export const jsxDEV = jsx;
-// Don't export jsxs again - it's already exported above

package/src/jsx-runtime.ts

@@ -1,226 +0,0 @@
-import type { Component } from './component';
-
-interface VNode {
-  type: string | Function;
-  props: Record<string, any>;
-}
-
-function jsx(type: string | Function, props: any, p0: string): VNode {
-  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: any }) => children;
-
-// Check if we're in a browser environment
-const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
-
-async function createElement(vnode: VNode | any): Promise<Node> {
-  console.log('Creating element from:', vnode);
-
-  // Create mock DOM elements when in Node environment
-  if (!isBrowser) {
-    // Return mock node objects in Node.js environment
-    if (vnode == null) {
-      return { nodeType: 3, textContent: '' } as any;
-    }
-    
-    if (typeof vnode === 'boolean') {
-      return { nodeType: 3, textContent: '' } as any;
-    }
-
-    if (typeof vnode === 'number' || typeof vnode === 'string') {
-      return { nodeType: 3, textContent: String(vnode) } as any;
-    }
-
-    // Handle arrays
-    if (Array.isArray(vnode)) {
-      const fragment = { nodeType: 11, childNodes: [] } as any;
-      for (const child of vnode) {
-        const node = await createElement(child);
-        fragment.childNodes.push(node);
-      }
-      return fragment;
-    }
-
-    // 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);
-          return node;
-        } catch (error) {
-          console.error('Error rendering component:', error);
-          return { nodeType: 3, textContent: '' } as any;
-        }
-      }
-
-      // Mock element creation
-      const element = { 
-        nodeType: 1, 
-        tagName: type, 
-        attributes: {}, 
-        style: {}, 
-        childNodes: [],
-        setAttribute: function(key: string, value: string) {
-          this.attributes[key] = value;
-        },
-        appendChild: function(child: any) {
-          this.childNodes.push(child);
-        }
-      } as any;
-      
-      // Handle props
-      for (const [key, value] of Object.entries(props || {})) {
-        if (key === 'children') continue;
-        if (key.startsWith('on') && typeof value === 'function') {
-          // Mock event handlers
-          const eventName = key.toLowerCase().slice(2);
-          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));
-        }
-      }
-
-      // 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;
-    }
-
-    // Handle other objects by converting to string
-    return { nodeType: 3, textContent: String(vnode) } as any;
-  }
-  
-  // Browser environment implementation
-  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));
-  }
-
-  // Handle arrays
-  if (Array.isArray(vnode)) {
-    const fragment = document.createDocumentFragment();
-    for (const child of vnode) {
-      const node = await createElement(child);
-      fragment.appendChild(node);
-    }
-    return fragment;
-  }
-
-  // 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('');
-      }
-    }
-
-    // Create DOM element
-    const element = document.createElement(type as string);
-    
-    // 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 as any).__events?.[eventName];
-        if (existingHandler) {
-          element.removeEventListener(eventName, existingHandler);
-        }
-        
-        // Add new event listener
-        element.addEventListener(eventName, value as EventListener);
-        if (!(element as any).__events) {
-          (element as any).__events = {};
-        }
-        (element as any).__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));
-      }
-    }
-
-    // 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;
-  }
-
-  // Handle other objects by converting to string
-  return document.createTextNode(String(vnode));
-}
-
-// Export named functions and aliases without duplicates
-export {
-  jsx,
-  jsx as jsxs,
-  jsx as jsxDEV,
-  Fragment,
-  createElement
-};
-
-// Named exports object
-const jsxRuntime = {
-  jsx,
-  jsxs: jsx,
-  jsxDEV: jsx,
-  Fragment,
-  createElement
-};
-
-export default jsxRuntime;

package/src/renderer.ts

@@ -1,55 +0,0 @@
-import { createElement } from './jsx-runtime';
-import { prepareRender, finishRender, setRenderCallback } from './hooks';
-import { batchUpdates } from './batch';
-
-// Track hydration state
-let isHydrating = false;
-
-/**
- * Hydrates a server-rendered component
- * @param element The element to hydrate
- * @param container The container element that contains server-rendered HTML
- */
-export async function hydrate(element: any, container: HTMLElement) {
-  isHydrating = true;
-  try {
-    await render(element, container);
-  } finally {
-    isHydrating = false;
-  }
-}
-
-/**
- * Renders a component to the DOM
- * @param element The element to render
- * @param container The container to render into
- */
-export async function render(element: any, container: HTMLElement) {
-  console.log('Rendering to:', container.id || 'unnamed-container');
-  
-  batchUpdates(async () => {
-    const rendererId = prepareRender();
-    try {
-      setRenderCallback(render, element, container);
-      const domNode = await createElement(element);
-      
-      // Don't clear container if we're hydrating
-      if (!isHydrating) {
-        container.innerHTML = '';
-      }
-      
-      // When hydrating, we should match and update existing nodes
-      // rather than appending new ones
-      if (isHydrating && container.firstChild) {
-        // During hydration, we assume the structure matches
-        // and just attach event handlers without replacing DOM
-        console.log('Hydrating existing DOM');
-      } else {
-        container.appendChild(domNode);
-      }
-      
-    } finally {
-      finishRender();
-    }
-  });
-}

package/src/server-renderer.ts

@@ -1,114 +0,0 @@
-import { prepareRender, finishRender, setRenderCallback } from './hooks';
-
-/**
- * Renders a component to a string
- */
-export async function renderToString(element: any): Promise<string> {
-  // Setup render context
-  const rendererId = prepareRender();
-  setRenderCallback(() => {}, element, null as any);
-  
-  try {
-    if (element == null) return '';
-    
-    if (typeof element === 'boolean') return '';
-    
-    if (typeof element === 'number' || typeof element === 'string') {
-      return escapeHtml(String(element));
-    }
-
-    if (Array.isArray(element)) {
-      const children = await Promise.all(element.map(renderToString));
-      return children.join('');
-    }
-
-    if ('type' in element && element.props !== undefined) {
-      const { type, props } = element;
-
-      // Handle function components
-      if (typeof type === 'function') {
-        try {
-          // Prepare new render context for the component
-          prepareRender();
-          const result = await type(props || {});
-          const html = await renderToString(result);
-          finishRender();
-          return html;
-        } catch (error) {
-          console.error('Error rendering component:', error);
-          return '';
-        }
-      }
-
-      // Handle Fragment special case
-      if (type === Symbol.for('react.fragment') || type.name === 'Fragment') {
-        if (props.children) {
-          const children = Array.isArray(props.children) ? props.children : [props.children];
-          const renderedChildren = await Promise.all(children.map(renderToString));
-          return renderedChildren.join('');
-        }
-        return '';
-      }
-
-      // Handle regular elements
-      let html = `<${type}`;
-
-      // Add attributes, skipping internal ones like 'key'
-      for (const [key, value] of Object.entries(props || {})) {
-        if (key === 'children' || key === 'key') continue;
-        if (key === 'className') {
-          html += ` class="${escapeHtml(String(value))}"`;
-        } else if (key === 'style' && typeof value === 'object') {
-          html += ` style="${stringifyStyle(value || {})}"`;
-        } else if (!key.startsWith('on')) {
-          html += ` ${key}="${escapeHtml(String(value))}"`;
-        }
-      }
-
-      // Handle self-closing tags
-      const voidElements = new Set([
-        'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
-        'link', 'meta', 'param', 'source', 'track', 'wbr'
-      ]);
-      
-      if (voidElements.has(type)) {
-        return html + '/>';
-      }
-
-      html += '>';
-
-      // Add children
-      if (props?.children) {
-        const children = Array.isArray(props.children) ? props.children : [props.children];
-        for (const child of children) {
-          html += await renderToString(child);
-        }
-      }
-
-      return html + `</${type}>`;
-    }
-
-    return escapeHtml(String(element));
-  } finally {
-    finishRender();
-  }
-}
-
-function escapeHtml(str: string): string {
-  return str
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#39;');
-}
-
-function stringifyStyle(style: Record<string, any>): string {
-  return Object.entries(style)
-    .map(([key, value]) => `${hyphenate(key)}:${value}`)
-    .join(';');
-}
-
-function hyphenate(str: string): string {
-  return str.replace(/[A-Z]/g, match => '-' + match.toLowerCase());
-}

package/src/shims.d.ts

@@ -1,20 +0,0 @@
-/**
- * Module declaration shims for third-party libraries
- */
-
-// Handle bcrypt CommonJS module in ESM context
-declare module 'bcrypt' {
-  export function genSalt(rounds?: number): Promise<string>;
-  export function hash(data: string, saltOrRounds: string | number): Promise<string>;
-  export function compare(data: string, encrypted: string): Promise<boolean>;
-  
-  // Allow either default or named imports to work
-  const bcrypt: {
-    genSalt: typeof genSalt;
-    hash: typeof hash;
-    compare: typeof compare;
-  };
-  export default bcrypt;
-}
-
-// Add similar declarations for other problematic Node.js modules if needed