Elysia Tools

Browse tools, examples, visual explainers, and topic guides from one clear workspace.

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Web Frameworks

Qwik Samples

Qwik framework examples including components, signals, state management, and zero-hydration patterns

Samples

Entries inside this sample collection

CodetsxSimple

Qwik Hello World

Basic Qwik component examples and Hello World applications with JSX

tsx
// Qwik Hello World Examples

import { component$, useSignal, useStore, $, useTask$ } from '@builder.io/qwik';

// 1. Basic functional component
export const HelloWorld = component$(() => {
    return <h1>Hello, World!</h1>;
});

// 2. Component with props
export interface GreetingProps {
    name: string;
}

export const Greeting = component$<GreetingProps>((props) => {
    return <h1>Hello, {props.name}!</h1>;
});

// 3. Component with signal (reactive state)
export const Counter = component$(() => {
    const count = useSignal(0);

    const increment = $(() => {
        count.value++;
    });

    const decrement = $(() => {
        count.value--;
    });

    return (
        <div>
            <h1>Count: {count.value}</h1>
            <button onClick$={increment}>Increment</button>
            <button onClick$={decrement}>Decrement</button>
        </div>
    );
});

// 4. Component with store (for complex objects)
export const UserProfile = component$(() => {
    const user = useStore({
        name: 'Guest',
        age: 25,
        isLoggedIn: false
    });

    const login = $(() => {
        user.name = 'John Doe';
        user.age = 30;
        user.isLoggedIn = true;
    });

    const logout = $(() => {
        user.name = 'Guest';
        user.age = 25;
        user.isLoggedIn = false;
    });

    const updateName = $((event: Event) => {
        const target = event.target as HTMLInputElement;
        user.name = target.value;
    });

    const updateAge = $((event: Event) => {
        const target = event.target as HTMLInputElement;
        user.age = parseInt(target.value);
    });

    return (
        <div>
            <h2>User Profile</h2>
            {user.isLoggedIn ? (
                <div>
                    <p>Name: {user.name}</p>
                    <p>Age: {user.age}</p>
                    <input
                        type="text"
                        value={user.name}
                        onInput$={updateName}
                        placeholder="Enter name"
                    />
                    <input
                        type="number"
                        value={user.age}
                        onInput$={updateAge}
                        placeholder="Enter age"
                    />
                    <button onClick$={logout}>Logout</button>
                </div>
            ) : (
                <button onClick$={login}>Login</button>
            )}
        </div>
    );
});

// 5. Component with computed values
export const ShoppingCart = component$(() => {
    const items = useStore([
        { name: 'Apple', price: 1.5, quantity: 2 },
        { name: 'Banana', price: 0.8, quantity: 5 }
    ]);

    const total = useSignal(0);
    const itemCount = useSignal(0);

    // UseTask$ for reactive computations
    useTask$(({ track }) => {
        track(() => items);
        total.value = items.reduce((sum, item) => sum + (item.price * item.quantity), 0);
        itemCount.value = items.reduce((sum, item) => sum + item.quantity, 0);
    });

    const removeItem = $((index: number) => {
        items.splice(index, 1);
    });

    return (
        <div>
            <h2>Shopping Cart</h2>
            <p>Items: {itemCount.value}</p>
            <p>Total: ${total.value.toFixed(2)}</p>
            <ul>
                {items.map((item, index) => (
                    <li key={index}>
                        {item.name} - ${item.price} x {item.quantity}
                        <button onClick$={() => removeItem(index)}>Remove</button>
                    </li>
                ))}
            </ul>
        </div>
    );
});

// 6. Async component with resource
import { Resource, useResource$ } from '@builder.io/qwik';

export interface Product {
    id: number;
    name: string;
    price: number;
}

export const ProductList = component$(() => {
    const productsResource = useResource$<Product[]>(async ({ track, cleanup }) => {
        // Track any reactive dependencies
        track(() => {/* track signals if needed */});

        // Cleanup function
        cleanup(() => {
            console.log('Cleaning up product fetch');
        });

        // Simulate API call
        await new Promise(resolve => setTimeout(resolve, 2000));

        return [
            { id: 1, name: 'Laptop', price: 999 },
            { id: 2, name: 'Phone', price: 699 },
            { id: 3, name: 'Tablet', price: 399 }
        ];
    });

    return (
        <div>
            <h2>Products</h2>
            <Resource
                value={productsResource}
                onPending={() => <div>Loading products...</div>}
                onRejected={(error) => <div>Error: {error.message}</div>}
                onResolved={(products) => (
                    <ul>
                        {products.map((product) => (
                            <li key={product.id}>
                                {product.name} - ${product.price}
                            </li>
                        ))}
                    </ul>
                )}
            />
        </div>
    );
});

// 7. Parent component demonstrating usage
export const App = component$(() => {
    return (
        <div>
            <HelloWorld />
            <Greeting name="Qwik" />
            <Counter />
            <UserProfile />
            <ShoppingCart />
            <ProductList />
        </div>
    );
});

// 8. Component with lifecycle hooks
import { useClientEffect$, useVisibleTask$ } from '@builder.io/qwik';

export const LifecycleDemo = component$(() => {
    const message = useSignal('Component mounted');

    // Runs on the client only (equivalent to componentDidMount)
    useClientEffect$(() => {
        console.log('Component mounted on client');
        message.value = 'Client effect executed';

        // Cleanup function
        return () => {
            console.log('Component will unmount');
        };
    });

    // Runs when component becomes visible
    useVisibleTask$(({ cleanup }) => {
        console.log('Component is visible');
        message.value = 'Visible task executed';

        cleanup(() => {
            console.log('Component hidden/cleaned up');
        });
    });

    return (
        <div>
            <h3>Lifecycle Demo</h3>
            <p>{message.value}</p>
        </div>
    );
});

// 9. Form handling
export const ContactForm = component$(() => {
    const form = useStore({
        name: '',
        email: '',
        message: '',
        submitted: false
    });

    const handleSubmit = $(async (event: Event) => {
        event.preventDefault();
        console.log('Form submitted:', form);

        // Simulate form submission
        await new Promise(resolve => setTimeout(resolve, 1000));

        form.submitted = true;

        // Reset form after 2 seconds
        setTimeout(() => {
            form.name = '';
            form.email = '';
            form.message = '';
            form.submitted = false;
        }, 2000);
    });

    return (
        <div>
            <h3>Contact Form</h3>
            {form.submitted ? (
                <p>Thank you for your submission!</p>
            ) : (
                <form onSubmit$={handleSubmit}>
                    <div>
                        <label>
                            Name:
                            <input
                                type="text"
                                value={form.name}
                                onInput$={(e) => form.name = (e.target as HTMLInputElement).value}
                                required
                            />
                        </label>
                    </div>
                    <div>
                        <label>
                            Email:
                            <input
                                type="email"
                                value={form.email}
                                onInput$={(e) => form.email = (e.target as HTMLInputElement).value}
                                required
                            />
                        </label>
                    </div>
                    <div>
                        <label>
                            Message:
                            <textarea
                                value={form.message}
                                onInput$={(e) => form.message = (e.target as HTMLTextAreaElement).value}
                                required
                            />
                        </label>
                    </div>
                    <button type="submit">Submit</button>
                </form>
            )}
        </div>
    );
});

export { App as HelloWorldExample };
CodetsxIntermediate

Qwik Signals and Stores

Working with reactive signals, stores, and state management in Qwik

tsx
// Qwik Signals and Stores

import {
    component$,
    useSignal,
    useStore,
    useTask$,
    $,
    useResource$,
    Resource
} from '@builder.io/qwik';

// 1. Basic signals
export const SignalDemo = component$(() => {
    const count = useSignal(0);
    const text = useSignal('Hello');
    const isVisible = useSignal(true);

    const increment = $(() => {
        count.value++;
    });

    const decrement = $(() => {
        count.value--;
    });

    const reset = $(() => {
        count.value = 0;
        text.value = 'Hello';
    });

    const toggle = $(() => {
        isVisible.value = !isVisible.value;
    });

    // Reactive computation with useTask$
    const doubled = useSignal(0);
    useTask$(({ track }) => {
        track(() => count.value);
        doubled.value = count.value * 2;
    });

    return (
        <div>
            <h3>Signal Demo</h3>
            <p>Count: {count.value}</p>
            <p>Doubled: {doubled.value}</p>
            <p>Text: {text.value}</p>

            <div>
                <button onClick$={increment}>+</button>
                <button onClick$={decrement}>-</button>
                <button onClick$={reset}>Reset</button>
            </div>

            <input
                type="text"
                value={text.value}
                onInput$={(e) => text.value = (e.target as HTMLInputElement).value}
            />

            <button onClick$={toggle}>
                {isVisible.value ? 'Hide' : 'Show'} Content
            </button>

            {isVisible.value && (
                <div>Toggle content is visible!</div>
            )}
        </div>
    );
});

// 2. Complex store
interface Todo {
    id: number;
    text: string;
    completed: boolean;
    createdAt: Date;
}

interface TodoStore {
    todos: Todo[];
    filter: 'all' | 'active' | 'completed';
    newTodoText: string;
}

export const TodoApp = component$(() => {
    const store = useStore<TodoStore>({
        todos: [],
        filter: 'all',
        newTodoText: ''
    });

    const filteredTodos = useSignal<Todo[]>([]);
    const stats = useSignal({ total: 0, completed: 0, active: 0 });

    // Reactive computations
    useTask$(({ track }) => {
        track(() => store.todos);
        track(() => store.filter);

        // Filter todos
        filteredTodos.value = store.todos.filter(todo => {
            switch (store.filter) {
                case 'active':
                    return !todo.completed;
                case 'completed':
                    return todo.completed;
                default:
                    return true;
            }
        });

        // Update stats
        stats.value = {
            total: store.todos.length,
            completed: store.todos.filter(todo => todo.completed).length,
            active: store.todos.filter(todo => !todo.completed).length
        };
    });

    const addTodo = $((event: Event) => {
        event.preventDefault();
        if (store.newTodoText.trim()) {
            store.todos.push({
                id: Date.now(),
                text: store.newTodoText.trim(),
                completed: false,
                createdAt: new Date()
            });
            store.newTodoText = '';
        }
    });

    const toggleTodo = $((id: number) => {
        const todo = store.todos.find(t => t.id === id);
        if (todo) {
            todo.completed = !todo.completed;
        }
    });

    const deleteTodo = $((id: number) => {
        const index = store.todos.findIndex(t => t.id === id);
        if (index !== -1) {
            store.todos.splice(index, 1);
        }
    });

    const clearCompleted = $(() => {
        store.todos = store.todos.filter(todo => !todo.completed);
    });

    const setFilter = $((filter: 'all' | 'active' | 'completed') => {
        store.filter = filter;
    });

    return (
        <div>
            <h3>Todo App</h3>

            <form onSubmit$={addTodo}>
                <input
                    type="text"
                    value={store.newTodoText}
                    onInput$={(e) => store.newTodoText = (e.target as HTMLInputElement).value}
                    placeholder="What needs to be done?"
                />
                <button type="submit">Add</button>
            </form>

            <div class="filters">
                <button
                    class={store.filter === 'all' ? 'active' : ''}
                    onClick$={() => setFilter('all')}
                >
                    All ({stats.value.total})
                </button>
                <button
                    class={store.filter === 'active' ? 'active' : ''}
                    onClick$={() => setFilter('active')}
                >
                    Active ({stats.value.active})
                </button>
                <button
                    class={store.filter === 'completed' ? 'active' : ''}
                    onClick$={() => setFilter('completed')}
                >
                    Completed ({stats.value.completed})
                </button>
            </div>

            <ul>
                {filteredTodos.value.map((todo) => (
                    <li key={todo.id} class={todo.completed ? 'completed' : ''}>
                        <input
                            type="checkbox"
                            checked={todo.completed}
                            onClick$={() => toggleTodo(todo.id)}
                        />
                        <span>{todo.text}</span>
                        <button onClick$={() => deleteTodo(todo.id)}>Delete</button>
                    </li>
                ))}
            </ul>

            {stats.value.completed > 0 && (
                <button onClick$={clearCompleted}>
                    Clear Completed ({stats.value.completed})
                </button>
            )}
        </div>
    );
});

// 3. Shopping cart with nested stores
interface CartItem {
    id: number;
    name: string;
    price: number;
    quantity: number;
}

interface CartStore {
    items: CartItem[];
    isOpen: boolean;
    couponCode: string;
    discount: number;
}

export const ShoppingCart = component$(() => {
    const cart = useStore<CartStore>({
        items: [],
        isOpen: false,
        couponCode: '',
        discount: 0
    });

    const total = useSignal(0);
    const subtotal = useSignal(0);
    const itemCount = useSignal(0);

    // Reactive calculations
    useTask$(({ track }) => {
        track(() => cart.items);
        track(() => cart.discount);

        subtotal.value = cart.items.reduce((sum, item) => sum + (item.price * item.quantity), 0);
        total.value = subtotal.value - (subtotal.value * cart.discount);
        itemCount.value = cart.items.reduce((sum, item) => sum + item.quantity, 0);
    });

    const addItem = $((item: Omit<CartItem, 'quantity'>) => {
        const existingItem = cart.items.find(i => i.id === item.id);
        if (existingItem) {
            existingItem.quantity++;
        } else {
            cart.items.push({ ...item, quantity: 1 });
        }
    });

    const removeItem = $((id: number) => {
        const index = cart.items.findIndex(item => item.id === id);
        if (index !== -1) {
            cart.items.splice(index, 1);
        }
    });

    const updateQuantity = $((id: number, quantity: number) => {
        const item = cart.items.find(item => item.id === id);
        if (item) {
            if (quantity <= 0) {
                removeItem(id);
            } else {
                item.quantity = quantity;
            }
        }
    });

    const toggleCart = $(() => {
        cart.isOpen = !cart.isOpen;
    });

    const applyCoupon = $(() => {
        // Simple coupon logic
        if (cart.couponCode === 'SAVE10') {
            cart.discount = 0.1;
        } else if (cart.couponCode === 'SAVE20') {
            cart.discount = 0.2;
        }
    });

    return (
        <div>
            <button onClick$={toggleCart}>
                Cart ({itemCount.value}) - ${total.value.toFixed(2)}
            </button>

            {cart.isOpen && (
                <div class="cart-modal">
                    <h3>Shopping Cart</h3>

                    {cart.items.length === 0 ? (
                        <p>Your cart is empty</p>
                    ) : (
                        <>
                            <ul>
                                {cart.items.map((item) => (
                                    <li key={item.id}>
                                        <div>
                                            <h4>{item.name}</h4>
                                            <p>${item.price} x {item.quantity} = ${(item.price * item.quantity).toFixed(2)}</p>
                                        </div>
                                        <div>
                                            <input
                                                type="number"
                                                value={item.quantity}
                                                min="1"
                                                onInput$={(e) => updateQuantity(item.id, parseInt((e.target as HTMLInputElement).value))}
                                            />
                                            <button onClick$={() => removeItem(item.id)}>Remove</button>
                                        </div>
                                    </li>
                                ))}
                            </ul>

                            <div class="cart-summary">
                                <p>Subtotal: ${subtotal.value.toFixed(2)}</p>
                                <p>Discount: {(cart.discount * 100).toFixed(0)}%</p>
                                <p><strong>Total: ${total.value.toFixed(2)}</strong></p>
                            </div>

                            <div class="coupon">
                                <input
                                    type="text"
                                    value={cart.couponCode}
                                    onInput$={(e) => cart.couponCode = (e.target as HTMLInputElement).value}
                                    placeholder="Coupon code"
                                />
                                <button onClick$={applyCoupon}>Apply</button>
                            </div>

                            <button onClick$={() => cart.items = []}>Clear Cart</button>
                        </>
                    )}

                    <button onClick$={toggleCart}>Close</button>
                </div>
            )}
        </div>
    );
});

// 4. Data fetching with stores
interface User {
    id: number;
    name: string;
    email: string;
    posts: Post[];
}

interface Post {
    id: number;
    title: string;
    body: string;
}

export const UserDashboard = component$(() => {
    const user = useStore<User | null>(null);
    const loading = useSignal(true);
    const error = useSignal<string | null>(null);

    // Resource for fetching user data
    const userResource = useResource$<User>(async ({ track }) => {
        track(() => {/* Track any signals if needed */});

        try {
            // Simulate API call
            await new Promise(resolve => setTimeout(resolve, 2000));

            return {
                id: 1,
                name: 'John Doe',
                email: 'john@example.com',
                posts: [
                    { id: 1, title: 'First Post', body: 'This is my first post' },
                    { id: 2, title: 'Second Post', body: 'This is my second post' }
                ]
            };
        } catch (err) {
            error.value = err instanceof Error ? err.message : 'Unknown error';
            throw err;
        }
    });

    const refreshData = $(async () => {
        loading.value = true;
        error.value = null;
        // Resource will automatically refetch
    });

    return (
        <div>
            <h2>User Dashboard</h2>
            <button onClick$={refreshData}>Refresh Data</button>

            <Resource
                value={userResource}
                onPending={() => <div>Loading user data...</div>}
                onRejected={(error) => <div>Error: {error.message}</div>}
                onResolved={(userData) => {
                    // Store the resolved data
                    user.value = userData;
                    loading.value = false;
                    return null; // We'll render from the store
                }}
            />

            {user.value && !loading.value && (
                <div>
                    <div class="user-info">
                        <h3>{user.value.name}</h3>
                        <p>{user.value.email}</p>
                    </div>

                    <div class="user-posts">
                        <h4>Posts ({user.value.posts.length})</h4>
                        <ul>
                            {user.value.posts.map((post) => (
                                <li key={post.id}>
                                    <h5>{post.title}</h5>
                                    <p>{post.body}</p>
                                </li>
                            ))}
                        </ul>
                    </div>
                </div>
            )}
        </div>
    );
});

// 5. Global state management
interface AppState {
    theme: 'light' | 'dark';
    user: User | null;
    notifications: string[];
}

// This would typically be in a separate file and used with context
export const createAppStore = (): AppState => ({
    theme: 'light',
    user: null,
    notifications: []
});

export const ThemeToggle = component$(() => {
    const appState = useStore(createAppStore());

    const toggleTheme = $(() => {
        appState.theme = appState.theme === 'light' ? 'dark' : 'light';
    });

    return (
        <div class={`theme-${appState.theme}`}>
            <button onClick$={toggleTheme}>
                Current theme: {appState.theme}
            </button>
        </div>
    );
});

export { SignalDemo, TodoApp, ShoppingCart, UserDashboard, ThemeToggle };
CodetsxComplex

Qwik Async and Lazy Loading

Async operations, lazy loading, and resumable rendering in Qwik

tsx
// Qwik Async and Lazy Loading

import {
    component$,
    useSignal,
    useStore,
    useTask$,
    $,
    useResource$,
    Resource,
    useVisibleTask$,
    lazy$,
    useStylesScoped$
} from '@builder.io/qwik';

// 1. Lazy loaded component
export const LazyComponent = component$(() => {
    const isVisible = useSignal(false);
    const data = useSignal<string>('');

    useVisibleTask$(() => {
        isVisible.value = true;
        // Load data only when component is visible
        setTimeout(() => {
            data.value = 'Lazy loaded data!';
        }, 1000);
    });

    return (
        <div>
            <h3>Lazy Component</h3>
            {isVisible.value ? (
                <div>
                    <p>Component is now visible!</p>
                    <p>{data.value || 'Loading...'}</p>
                </div>
            ) : (
                <p>Component will load when visible...</p>
            )}
        </div>
    );
});

// 2. Using lazy$ for code splitting
const HeavyComponent = lazy$(() => import('./heavy-component'));

export const LazyLoadDemo = component$(() => {
    const showHeavyComponent = useSignal(false);

    return (
        <div>
            <h3>Lazy Load Demo</h3>
            <button
                onClick$={() => showHeavyComponent.value = true}
            >
                Load Heavy Component
            </button>

            {showHeavyComponent.value && (
                <HeavyComponent />
            )}
        </div>
    );
});

// 3. Resource management with cleanup
export const ResourceManagement = component$(() => {
    const data = useSignal<string[]>([]);
    const loading = useSignal(false);
    const error = useSignal<string | null>(null);
    const intervalId = useSignal<number | null>(null);

    const startPolling = $(() => {
        loading.value = true;
        error.value = null;

        // Simulate polling API
        intervalId.value = window.setInterval(async () => {
            try {
                // Simulate API call
                await new Promise(resolve => setTimeout(resolve, 1000));
                const newData = `Data ${Date.now()}`;
                data.value = [...data.value, newData];
                loading.value = false;
            } catch (err) {
                error.value = err instanceof Error ? err.message : 'Unknown error';
                loading.value = false;
            }
        }, 2000);
    });

    const stopPolling = $(() => {
        if (intervalId.value) {
            clearInterval(intervalId.value);
            intervalId.value = null;
        }
    });

    const clearData = $(() => {
        data.value = [];
    });

    // Cleanup on unmount
    useVisibleTask$(({ cleanup }) => {
        cleanup(() => {
            stopPolling();
        });
    });

    return (
        <div>
            <h3>Resource Management</h3>

            <div>
                <button onClick$={startPolling}>Start Polling</button>
                <button onClick$={stopPolling}>Stop Polling</button>
                <button onClick$={clearData}>Clear Data</button>
            </div>

            {loading.value && <p>Loading...</p>}
            {error.value && <p style="color: red">Error: {error.value}</p>}

            <ul>
                {data.value.map((item, index) => (
                    <li key={index}>{item}</li>
                ))}
            </ul>

            <p>Status: {intervalId.value ? 'Polling' : 'Stopped'}</p>
        </div>
    );
});

// 4. Advanced async patterns
interface AsyncData {
    id: number;
    title: string;
    description: string;
    metadata: {
        created: Date;
        updated: Date;
        tags: string[];
    };
}

export const AsyncPatterns = component$(() => {
    const items = useSignal<AsyncData[]>([]);
    const loading = useSignal(false);
    const currentFilter = useSignal('all');

    // Complex resource with filtering and caching
    const itemsResource = useResource$<AsyncData[]>(async ({ track }) => {
        track(() => currentFilter.value);

        loading.value = true;

        try {
            // Simulate API call with different endpoints based on filter
            let endpoint = '/api/items';
            if (currentFilter.value !== 'all') {
                endpoint += `?filter=${currentFilter.value}`;
            }

            console.log('Fetching from:', endpoint);

            // Simulate network delay and different responses
            await new Promise(resolve => setTimeout(resolve, 1500));

            const allItems: AsyncData[] = [
                {
                    id: 1,
                    title: 'Item 1',
                    description: 'Description for item 1',
                    metadata: {
                        created: new Date('2023-01-01'),
                        updated: new Date('2023-12-01'),
                        tags: ['tag1', 'tag2']
                    }
                },
                {
                    id: 2,
                    title: 'Item 2',
                    description: 'Description for item 2',
                    metadata: {
                        created: new Date('2023-02-01'),
                        updated: new Date('2023-11-01'),
                        tags: ['tag2', 'tag3']
                    }
                },
                {
                    id: 3,
                    title: 'Item 3',
                    description: 'Description for item 3',
                    metadata: {
                        created: new Date('2023-03-01'),
                        updated: new Date('2023-10-01'),
                        tags: ['tag1', 'tag3']
                    }
                }
            ];

            // Apply filtering logic
            let filteredItems = allItems;
            if (currentFilter.value !== 'all') {
                filteredItems = allItems.filter(item =>
                    item.metadata.tags.includes(currentFilter.value)
                );
            }

            return filteredItems;
        } catch (err) {
            console.error('Failed to fetch items:', err);
            throw err;
        } finally {
            loading.value = false;
        }
    });

    const setFilter = $((filter: string) => {
        currentFilter.value = filter;
    });

    const refreshItems = $(() => {
        // Force resource refetch by changing a dependency
        const temp = currentFilter.value;
        currentFilter.value = '';
        setTimeout(() => {
            currentFilter.value = temp;
        }, 10);
    });

    return (
        <div>
            <h3>Advanced Async Patterns</h3>

            <div class="filters">
                <button
                    class={currentFilter.value === 'all' ? 'active' : ''}
                    onClick$={() => setFilter('all')}
                >
                    All
                </button>
                <button
                    class={currentFilter.value === 'tag1' ? 'active' : ''}
                    onClick$={() => setFilter('tag1')}
                >
                    Tag 1
                </button>
                <button
                    class={currentFilter.value === 'tag2' ? 'active' : ''}
                    onClick$={() => setFilter('tag2')}
                >
                    Tag 2
                </button>
                <button
                    class={currentFilter.value === 'tag3' ? 'active' : ''}
                    onClick$={() => setFilter('tag3')}
                >
                    Tag 3
                </button>
                <button onClick$={refreshItems}>Refresh</button>
            </div>

            <Resource
                value={itemsResource}
                onPending={() => <div>Loading items...</div>}
                onRejected={(error) => (
                    <div style="color: red">
                        Error loading items: {error.message}
                    </div>
                )}
                onResolved={(items) => {
                    return (
                        <div>
                            <p>Found {items.length} items</p>
                            <ul>
                                {items.map((item) => (
                                    <li key={item.id} class="item-card">
                                        <h4>{item.title}</h4>
                                        <p>{item.description}</p>
                                        <div class="metadata">
                                            <small>
                                                Created: {item.metadata.created.toLocaleDateString()} |
                                                Updated: {item.metadata.updated.toLocaleDateString()}
                                            </small>
                                            <div class="tags">
                                                {item.metadata.tags.map((tag) => (
                                                    <span key={tag} class="tag">
                                                        {tag}
                                                    </span>
                                                ))}
                                            </div>
                                        </div>
                                    </li>
                                ))}
                            </ul>
                        </div>
                    );
                }}
            />

            {loading.value && <div class="loading-indicator">Processing...</div>}
        </div>
    );
});

// 5. Progressive enhancement with async
export const ProgressiveEnhancement = component$(() => {
    const isClient = useSignal(false);
    const features = useSignal<string[]>([]);

    // Check if we're on the client
    useVisibleTask$(() => {
        isClient.value = true;

        // Detect available features
        const detectedFeatures: string[] = [];
        if ('serviceWorker' in navigator) {
            detectedFeatures.push('Service Worker');
        }
        if ('IntersectionObserver' in window) {
            detectedFeatures.push('Intersection Observer');
        }
        if ('WebAssembly' in window) {
            detectedFeatures.push('WebAssembly');
        }
        if ('localStorage' in window) {
            detectedFeatures.push('Local Storage');
        }

        features.value = detectedFeatures;
    });

    const loadAdvancedFeature = $(async () => {
        if (!isClient.value) return;

        try {
            // Simulate loading an advanced feature
            const module = await import('./advanced-feature');
            console.log('Advanced feature loaded:', module);
            features.value = [...features.value, 'Advanced Feature'];
        } catch (err) {
            console.error('Failed to load advanced feature:', err);
        }
    });

    const testAsyncOperation = $(async () => {
        const result = await new Promise<string>((resolve) => {
            setTimeout(() => {
                resolve('Async operation completed!');
            }, 2000);
        });

        alert(result);
    });

    return (
        <div>
            <h3>Progressive Enhancement</h3>

            <div class="client-info">
                <p>Environment: {isClient.value ? 'Client' : 'Server'}</p>
                {isClient.value && (
                    <div>
                        <p>Available Features:</p>
                        <ul>
                            {features.value.map((feature, index) => (
                                <li key={index}>{feature}</li>
                            ))}
                        </ul>
                    </div>
                )}
            </div>

            {isClient.value && (
                <div class="client-only-features">
                    <button onClick$={loadAdvancedFeature}>
                        Load Advanced Feature
                    </button>
                    <button onClick$={testAsyncOperation}>
                        Test Async Operation
                    </button>
                </div>
            )}

            {!isClient.value && (
                <div class="server-fallback">
                    <p>This content works even without JavaScript!</p>
                </div>
            )}
        </div>
    );
});

// 6. Optimistic updates
export const OptimisticUpdates = component$(() => {
    const posts = useSignal<{ id: number; title: string; likes: number }[]>([
        { id: 1, title: 'Post 1', likes: 5 },
        { id: 2, title: 'Post 2', likes: 3 }
    ]);
    const pendingLikes = useSignal<number[]>([]);

    const likePost = $(async (postId: number) => {
        // Optimistic update
        const post = posts.value.find(p => p.id === postId);
        if (post) {
            post.likes++;
            pendingLikes.value = [...pendingLikes.value, postId];
        }

        try {
            // Simulate API call
            await new Promise(resolve => setTimeout(resolve, 1000));

            // Server succeeded - remove from pending
            pendingLikes.value = pendingLikes.value.filter(id => id !== postId);
        } catch (err) {
            // Revert optimistic update
            if (post) {
                post.likes--;
            }
            pendingLikes.value = pendingLikes.value.filter(id => id !== postId);
            alert('Failed to like post. Please try again.');
        }
    });

    const addComment = $(async (postId: number, comment: string) => {
        if (!comment.trim()) return;

        // Optimistic update would go here
        try {
            // Simulate API call
            await new Promise(resolve => setTimeout(resolve, 1500));
            alert('Comment added successfully!');
        } catch (err) {
            alert('Failed to add comment. Please try again.');
        }
    });

    return (
        <div>
            <h3>Optimistic Updates</h3>

            {posts.value.map((post) => (
                <div key={post.id} class="post">
                    <h4>{post.title}</h4>
                    <div class="post-actions">
                        <button
                            onClick$={() => likePost(post.id)}
                            disabled={pendingLikes.value.includes(post.id)}
                        >
                            {pendingLikes.value.includes(post.id) ? 'Liking...' : `Like (${post.likes})`}
                        </button>
                    </div>
                </div>
            ))}
        </div>
    );
});

// Add some scoped styles
useStylesScoped$(`
    .filters {
        margin-bottom: 1rem;
    }

    .filters button {
        margin-right: 0.5rem;
        padding: 0.5rem 1rem;
        border: 1px solid #ccc;
        background: white;
        cursor: pointer;
    }

    .filters button.active {
        background: #007bff;
        color: white;
        border-color: #007bff;
    }

    .item-card {
        border: 1px solid #ddd;
        padding: 1rem;
        margin-bottom: 1rem;
        border-radius: 4px;
    }

    .metadata {
        margin-top: 0.5rem;
    }

    .tags {
        margin-top: 0.25rem;
    }

    .tag {
        display: inline-block;
        background: #f0f0f0;
        padding: 0.25rem 0.5rem;
        margin-right: 0.25rem;
        border-radius: 3px;
        font-size: 0.8rem;
    }

    .loading-indicator {
        margin-top: 1rem;
        padding: 0.5rem;
        background: #f8f9fa;
        border-left: 4px solid #007bff;
    }

    .post {
        border: 1px solid #ddd;
        padding: 1rem;
        margin-bottom: 1rem;
        border-radius: 4px;
    }

    .post-actions button {
        margin-right: 0.5rem;
    }

    .post-actions button:disabled {
        opacity: 0.6;
        cursor: not-allowed;
    }
`);

export {
    LazyComponent,
    LazyLoadDemo,
    ResourceManagement,
    AsyncPatterns,
    ProgressiveEnhancement,
    OptimisticUpdates
};
CodetsxComplex

Qwik Best Practices and Patterns

Best practices, performance patterns, and optimization techniques for Qwik applications

tsx
// Qwik Best Practices and Patterns

import {
    component$,
    useSignal,
    useStore,
    useTask$,
    $,
    useResource$,
    Resource,
    useVisibleTask$,
    useClientEffect$,
    useStylesScoped$,
    useBrowserVisibleTask$
} from '@builder.io/qwik';

// 1. Component decomposition and reusability
interface ButtonProps {
    onClick$: () => void;
    variant?: 'primary' | 'secondary' | 'danger';
    size?: 'small' | 'medium' | 'large';
    disabled?: boolean;
    loading?: boolean;
}

export const Button = component$<ButtonProps>((props) => {
    return (
        <button
            class={`btn btn-${props.variant || 'primary'} btn-${props.size || 'medium'}`}
            onClick$={props.onClick$}
            disabled={props.disabled || props.loading}
        >
            {props.loading ? 'Loading...' : props.children}
        </button>
    );
});

// 2. Custom hooks pattern
export const useDebounce = <T,>(value: T, delay: number) => {
    const debouncedValue = useSignal(value);

    useTask$(({ track }) => {
        track(() => value);

        const timer = setTimeout(() => {
            debouncedValue.value = value;
        }, delay);

        return () => clearTimeout(timer);
    });

    return debouncedValue;
};

export const useLocalStorage = <T,>(key: string, initialValue: T) => {
    const value = useSignal<T>(initialValue);

    useClientEffect$(() => {
        // Load from localStorage on mount
        const stored = localStorage.getItem(key);
        if (stored !== null) {
            value.value = JSON.parse(stored);
        }

        // Save to localStorage when value changes
        return () => {
            localStorage.setItem(key, JSON.stringify(value.value));
        };
    });

    return value;
};

// 3. Performance optimization patterns
export const VirtualizedList = component$<{
    items: any[];
    itemHeight: number;
    containerHeight: number;
    renderItem: (item: any, index: number) => any;
}>((props) => {
    const scrollTop = useSignal(0);
    const startIndex = useSignal(0);
    const endIndex = useSignal(0);

    useTask$(({ track }) => {
        track(() => scrollTop.value);
        track(() => props.items);

        start = Math.floor(scrollTop.value / props.itemHeight);
        end = Math.min(
            start + Math.ceil(props.containerHeight / props.itemHeight) + 1,
            props.items.length
        );

        startIndex.value = start;
        endIndex.value = end;
    });

    const handleScroll = $((event: Event) => {
        const target = event.target as HTMLElement;
        scrollTop.value = target.scrollTop;
    });

    let start = 0;
    let end = 10;

    return (
        <div
            style={{
                height: `${props.containerHeight}px`,
                overflow: 'auto'
            }}
            onScroll$={handleScroll}
        >
            <div
                style={{
                    height: `${props.items.length * props.itemHeight}px`,
                    position: 'relative'
                }}
            >
                {props.items.slice(startIndex.value, endIndex.value).map((item, index) => (
                    <div
                        key={index}
                        style={{
                            position: 'absolute',
                            top: `${(startIndex.value + index) * props.itemHeight}px`,
                            height: `${props.itemHeight}px`,
                            width: '100%'
                        }}
                    >
                        {props.renderItem(item, startIndex.value + index)}
                    </div>
                ))}
            </div>
        </div>
    );
});

// 4. Error boundaries and error handling
interface ErrorBoundaryProps {
    fallback: (error: Error, reset: () => void) => any;
}

export const ErrorBoundary = component$<ErrorBoundaryProps>((props) => {
    const error = useSignal<Error | null>(null);
    const hasError = useSignal(false);

    useTask$(({ track }) => {
        track(() => props.children);

        // In a real implementation, you would catch errors from children
        // This is a simplified example
    });

    const reset = $(() => {
        error.value = null;
        hasError.value = false;
    });

    return (
        <>
            {hasError.value && error.value ? (
                props.fallback(error.value, reset)
            ) : (
                props.children
            )}
        </>
    );
});

// 5. Optimized form handling
export const OptimizedForm = component$(() => {
    const form = useStore({
        email: '',
        password: '',
        errors: {} as Record<string, string>,
        touched: {} as Record<string, boolean>
    });

    const isSubmitting = useSignal(false);
    const debouncedEmail = useDebounce(form.email, 500);
    const emailValid = useSignal(true);

    // Validate email on debounce
    useTask$(({ track }) => {
        track(() => debouncedEmail.value);

        if (form.touched.email) {
            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
            emailValid.value = emailRegex.test(debouncedEmail.value);

            if (!emailValid.value) {
                form.errors.email = 'Please enter a valid email address';
            } else {
                delete form.errors.email;
            }
        }
    });

    const handleFieldBlur = $((fieldName: string) => {
        form.touched[fieldName] = true;
    });

    const handleSubmit = $(async (event: Event) => {
        event.preventDefault();
        isSubmitting.value = true;

        // Mark all fields as touched
        form.touched.email = true;
        form.touched.password = true;

        // Validate all fields
        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        if (!emailRegex.test(form.email)) {
            form.errors.email = 'Please enter a valid email address';
        }

        if (form.password.length < 8) {
            form.errors.password = 'Password must be at least 8 characters';
        }

        // Submit if no errors
        if (Object.keys(form.errors).length === 0) {
            try {
                // Simulate API call
                await new Promise(resolve => setTimeout(resolve, 2000));
                alert('Form submitted successfully!');
            } catch (err) {
                alert('Submission failed. Please try again.');
            }
        }

        isSubmitting.value = false;
    });

    return (
        <form onSubmit$={handleSubmit}>
            <div class="form-group">
                <label>Email:</label>
                <input
                    type="email"
                    value={form.email}
                    onInput$={(e) => form.email = (e.target as HTMLInputElement).value}
                    onBlur$={() => handleFieldBlur('email')}
                    class={form.touched.email && form.errors.email ? 'error' : ''}
                />
                {form.touched.email && form.errors.email && (
                    <span class="error-message">{form.errors.email}</span>
                )}
            </div>

            <div class="form-group">
                <label>Password:</label>
                <input
                    type="password"
                    value={form.password}
                    onInput$={(e) => form.password = (e.target as HTMLInputElement).value}
                    onBlur$={() => handleFieldBlur('password')}
                    class={form.touched.password && form.errors.password ? 'error' : ''}
                />
                {form.touched.password && form.errors.password && (
                    <span class="error-message">{form.errors.password}</span>
                )}
            </div>

            <Button
                type="submit"
                variant="primary"
                loading={isSubmitting.value}
                disabled={isSubmitting.value}
            >
                Submit
            </Button>
        </form>
    );
});

// 6. Memory optimization patterns
export const MemoryOptimizedComponent = component$(() => {
    const data = useSignal<any[]>([]);
    const activeItem = useSignal<any | null>(null);
    const subscriptions = useSignal<(() => void)[]>([]);

    // Proper cleanup pattern
    useVisibleTask$(({ cleanup }) => {
        // Setup subscriptions or timers
        const timer = setInterval(() => {
            console.log('Timer running');
        }, 1000);

        // Add cleanup function
        cleanup(() => {
            clearInterval(timer);

            // Cleanup all subscriptions
            subscriptions.value.forEach(unsubscribe => unsubscribe());
            subscriptions.value = [];
        });
    });

    const loadMoreData = $(async () => {
        // Load data efficiently
        try {
            const response = await fetch('/api/data');
            const newData = await response.json();

            // Process data in chunks to avoid blocking
            const chunkSize = 100;
            for (let i = 0; i < newData.length; i += chunkSize) {
                const chunk = newData.slice(i, i + chunkSize);
                data.value = [...data.value, ...chunk];

                // Allow UI to update
                await new Promise(resolve => setTimeout(resolve, 10));
            }
        } catch (err) {
            console.error('Failed to load data:', err);
        }
    });

    return (
        <div>
            <h3>Memory Optimized Component</h3>
            <button onClick$={loadMoreData}>Load More Data</button>
            <p>Data items: {data.value.length}</p>
        </div>
    );
});

// 7. Responsive design patterns
export const ResponsiveLayout = component$(() => {
    const screenSize = useSignal<'mobile' | 'tablet' | 'desktop'>('desktop');
    const menuOpen = useSignal(false);

    useBrowserVisibleTask$(() => {
        const updateScreenSize = () => {
            const width = window.innerWidth;
            if (width < 768) {
                screenSize.value = 'mobile';
            } else if (width < 1024) {
                screenSize.value = 'tablet';
            } else {
                screenSize.value = 'desktop';
            }
        };

        updateScreenSize();
        window.addEventListener('resize', updateScreenSize);

        return () => {
            window.removeEventListener('resize', updateScreenSize);
        };
    });

    const toggleMenu = $(() => {
        menuOpen.value = !menuOpen.value;
    });

    return (
        <div class={`layout layout-${screenSize.value}`}>
            <header class="header">
                <h1>My App</h1>
                {screenSize.value === 'mobile' && (
                    <button onClick$={toggleMenu}>Menu</button>
                )}
            </header>

            <div class="container">
                <aside class={`sidebar ${menuOpen.value ? 'open' : ''}`}>
                    <nav>
                        <a href="/">Home</a>
                        <a href="/about">About</a>
                        <a href="/contact">Contact</a>
                    </nav>
                </aside>

                <main class="main">
                    <p>Screen size: {screenSize.value}</p>
                    {screenSize.value === 'mobile' && (
                        <p>Mobile menu is {menuOpen.value ? 'open' : 'closed'}</p>
                    )}
                </main>
            </div>
        </div>
    );
});

// 8. Performance monitoring
export const PerformanceMonitor = component$(() => {
    const metrics = useStore({
        renderTime: 0,
        componentCount: 0,
        memoryUsage: 0
    });

    const startTime = useSignal(Date.now());

    useVisibleTask$(() => {
        const endTime = Date.now();
        metrics.renderTime = endTime - startTime.value;

        // Monitor memory usage if available
        if ('memory' in performance) {
            const memory = (performance as any).memory;
            metrics.memoryUsage = Math.round(memory.usedJSHeapSize / 1024 / 1024);
        }

        // Monitor performance metrics
        if ('PerformanceObserver' in window) {
            const observer = new PerformanceObserver((list) => {
                for (const entry of list.getEntries()) {
                    if (entry.entryType === 'measure') {
                        console.log(`Performance measure: ${entry.name} - ${entry.duration}ms`);
                    }
                }
            });
            observer.observe({ entryTypes: ['measure'] });
        }
    });

    return (
        <div class="performance-monitor">
            <h3>Performance Metrics</h3>
            <ul>
                <li>Render time: {metrics.renderTime}ms</li>
                <li>Memory usage: {metrics.memoryUsage}MB</li>
                <li>Components: {metrics.componentCount}</li>
            </ul>
        </div>
    );
});

// Add scoped styles for all components
useStylesScoped$(`
    .btn {
        padding: 0.5rem 1rem;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        font-size: 0.875rem;
        transition: all 0.2s;
    }

    .btn-primary {
        background: #007bff;
        color: white;
    }

    .btn-secondary {
        background: #6c757d;
        color: white;
    }

    .btn-danger {
        background: #dc3545;
        color: white;
    }

    .btn-small {
        padding: 0.25rem 0.5rem;
        font-size: 0.75rem;
    }

    .btn-medium {
        padding: 0.5rem 1rem;
        font-size: 0.875rem;
    }

    .btn-large {
        padding: 1rem 2rem;
        font-size: 1rem;
    }

    .btn:disabled {
        opacity: 0.6;
        cursor: not-allowed;
    }

    .form-group {
        margin-bottom: 1rem;
    }

    .form-group label {
        display: block;
        margin-bottom: 0.5rem;
        font-weight: 500;
    }

    .form-group input {
        width: 100%;
        padding: 0.5rem;
        border: 1px solid #ddd;
        border-radius: 4px;
    }

    .form-group input.error {
        border-color: #dc3545;
    }

    .error-message {
        color: #dc3545;
        font-size: 0.875rem;
        margin-top: 0.25rem;
        display: block;
    }

    .layout {
        display: flex;
        flex-direction: column;
        min-height: 100vh;
    }

    .header {
        padding: 1rem;
        background: #f8f9fa;
        border-bottom: 1px solid #ddd;
        display: flex;
        justify-content: space-between;
        align-items: center;
    }

    .container {
        display: flex;
        flex: 1;
    }

    .sidebar {
        width: 250px;
        background: #f8f9fa;
        border-right: 1px solid #ddd;
        transition: transform 0.3s;
    }

    .layout-mobile .sidebar {
        position: fixed;
        top: 0;
        left: 0;
        height: 100vh;
        z-index: 1000;
        transform: translateX(-100%);
    }

    .layout-mobile .sidebar.open {
        transform: translateX(0);
    }

    .main {
        flex: 1;
        padding: 1rem;
    }

    .performance-monitor {
        position: fixed;
        bottom: 20px;
        right: 20px;
        background: rgba(0, 0, 0, 0.8);
        color: white;
        padding: 1rem;
        border-radius: 4px;
        font-size: 0.875rem;
    }

    .performance-monitor h3 {
        margin: 0 0 0.5rem 0;
        font-size: 1rem;
    }

    .performance-monitor ul {
        margin: 0;
        padding-left: 1rem;
    }

    .performance-monitor li {
        margin-bottom: 0.25rem;
    }
`);

export {
    Button,
    useDebounce,
    useLocalStorage,
    VirtualizedList,
    ErrorBoundary,
    OptimizedForm,
    MemoryOptimizedComponent,
    ResponsiveLayout,
    PerformanceMonitor
};

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Infer JSON Schema from Samples and Spreadsheets

Derive a reviewable JSON Schema draft from representative JSON samples or XLSX rows, then inspect types, requiredness, nulls, and outliers before treating it as a contract.

Hub

Population Ecology, Biodiversity, and Food Web Calculators

Use educational ecology models to explore population growth, carrying capacity, species interactions, sampled biodiversity, and trophic energy transfer.

Hub

Authorized Webhook Capture and Endpoint Trust Checks

Capture and replay controlled webhook requests, inspect delivery evidence, and check the receiver HTTPS certificate without treating a valid certificate as proof of business trust.

Hub

Observability Debugging from Logs, Traces, Webhooks, and JSON Payloads

Parse logs, decode traces, inspect webhook/API evidence, explore JSON payloads, and extract recurring patterns before writing an incident-ready debugging note.

Home
Tools3212
Samples593
Visualizations471
Viewers103
Hubs239
Tags333
Images, Audio & Video657

Image, audio, and video processing, conversion, and optimization tools

Math, Date & Finance647

Calculators, numerics, date logic, statistics, and finance tools

Design & Color298

Color, layout, graphics, visual styling, and design helper tools

Text & Writing209

Writing, cleanup, formatting, extraction, and text analysis tools

Developer & Web193

Developer utilities, networking, web debugging, and automation helpers

Conversion & Encoding175

Format, file, archive, unit, and encoding conversion tools

Lead Generation Quiz Launch and Contact Handoff
Memorial Drafts: Family Review and Print Handoff
Private Habit Records: Backup, Restore and Sharing Review
Article to X and LinkedIn Drafts: Fact Review and Handoff
Markdown Interactive Deck Review and Offline Handoff

© 2026 Elysia Tools. All rights reserved.

DocsPricingAboutTerms of ServicePrivacy PolicyCookiesContact
Web Frameworks

Solid.js Samples

Solid.js reactive framework examples including components, signals, stores, and modern Solid patterns

Web Frameworks

Angular Framework Samples

Essential Angular examples for enterprise web development with TypeScript, components, and modules

Web Frameworks

Fastify Samples

Fastify high-performance Node.js web framework examples including plugins, hooks, validation, and optimization techniques

Web Frameworks

Fiber Samples

Fiber Go web framework examples including routing, middleware, templates, WebSocket, database integration, and performance optimization

Web Frameworks

Lit Samples

Lit web components examples including reactive properties, lifecycle hooks, templates, and modern component patterns

Web Frameworks

Preact Samples

Preact framework examples including components, hooks, routing, and modern Preact patterns