frontend-hamroun 1.2.16 → 1.2.17

package/dist/renderer.js

@@ -1,51 +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, container) {
-    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, container) {
-    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/dist/server-renderer.js

@@ -1,102 +0,0 @@
-import { prepareRender, finishRender, setRenderCallback } from './hooks';
-/**
- * Renders a component to a string
- */
-export async function renderToString(element) {
-    // Setup render context
-    const rendererId = prepareRender();
-    setRenderCallback(() => { }, element, null);
-    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) {
-    return str
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#39;');
-}
-function stringifyStyle(style) {
-    return Object.entries(style)
-        .map(([key, value]) => `${hyphenate(key)}:${value}`)
-        .join(';');
-}
-function hyphenate(str) {
-    return str.replace(/[A-Z]/g, match => '-' + match.toLowerCase());
-}

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/vdom.js

@@ -1,27 +0,0 @@
-function arePropsEqual(oldProps, newProps) {
-    // Handle null/undefined props
-    oldProps = oldProps || {};
-    newProps = newProps || {};
-    const oldKeys = Object.keys(oldProps).filter(k => k !== 'children');
-    const newKeys = Object.keys(newProps).filter(k => k !== 'children');
-    if (oldKeys.length !== newKeys.length)
-        return false;
-    return oldKeys.every(key => oldProps[key] === newProps[key]);
-}
-export function diff(oldNode, newNode) {
-    if (oldNode == null || newNode == null)
-        return oldNode !== newNode;
-    if (typeof oldNode !== typeof newNode)
-        return true;
-    if (typeof newNode === 'string' || typeof newNode === 'number')
-        return oldNode !== newNode;
-    // Handle primitive values that are not objects
-    if (!oldNode.type || !newNode.type)
-        return oldNode !== newNode;
-    if (newNode.type !== oldNode.type)
-        return true;
-    return !arePropsEqual(oldNode.props, newNode.props);
-}
-export function shouldComponentUpdate(oldProps, newProps) {
-    return !arePropsEqual(oldProps, newProps);
-}