frontend-hamroun 1.1.90 → 1.2.0

package/src/index.ts

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

package/src/jsx-runtime/index.ts

@@ -0,0 +1,24 @@
+import { jsx, jsxs, createElement, Fragment } from './jsx-runtime';
+
+export {
+  jsx,
+  jsxs,
+  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).Fragment = Fragment;
+}
+
+// Default export for module usage
+export default {
+  jsx,
+  jsxs,
+  createElement,
+  Fragment
+};

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

@@ -0,0 +1,99 @@
+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
+  };
+}
+
+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');

package/src/jsx-runtime.ts

@@ -0,0 +1,226 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,114 @@
+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/types/bcrypt.d.ts

@@ -0,0 +1,30 @@
+declare module 'bcrypt' {
+  /**
+   * Generate a salt
+   * @param rounds Number of rounds to use, defaults to 10
+   * @param callback Callback function (err, salt)
+   */
+  export function genSalt(rounds?: number, callback?: (err: Error | null, salt: string) => void): Promise<string>;
+  
+  /**
+   * Generate a hash for the provided string
+   * @param data Data to hash
+   * @param saltOrRounds Salt or number of rounds to use
+   * @param callback Callback function (err, hash)
+   */
+  export function hash(data: string, saltOrRounds: string | number, callback?: (err: Error | null, hash: string) => void): Promise<string>;
+  
+  /**
+   * Compare provided data with a hash
+   * @param data Data to compare
+   * @param encrypted Hash to compare against
+   * @param callback Callback function (err, result)
+   */
+  export function compare(data: string, encrypted: string, callback?: (err: Error | null, result: boolean) => void): Promise<boolean>;
+  
+  /**
+   * Get the number of rounds used in the specified hash
+   * @param encrypted Hash to extract rounds from
+   */
+  export function getRounds(encrypted: string): number;
+}