Elysia Tools

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

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Web Frameworks

React Samples

React.js component examples including hooks, state management, routing, and modern React patterns

Samples

Entries inside this sample collection

CodejavascriptSimple

React Hello World

Basic React component examples and Hello World applications with JSX

Difficulty

2/10

Estimated time

15 min

Tags

react, jsx, components, hooks

Prerequisites

JavaScript basics, HTML basics

javascript
// React Hello World Examples

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

// 2. Component with props
function Greeting({ name }) {
    return <h1>Hello, {name}!</h1>;
}

// 3. Components with hooks
import { useState, useEffect } from 'react';

function Counter() {
    const [count, setCount] = useState(0);

    return (
        <div>
            <h1>Count: {count}</h1>
            <button onClick={() => setCount(count + 1)}>
                Increment
            </button>
            <button onClick={() => setCount(count - 1)}>
                Decrement
            </button>
        </div>
    );
}

// 4. Component with multiple states
function UserForm() {
    const [name, setName] = useState('');
    const [email, setEmail] = useState('');

    const handleSubmit = (e) => {
        e.preventDefault();
        alert(`Name: ${name}, Email: ${email}`);
    };

    return (
        <form onSubmit={handleSubmit}>
            <div>
                <label>Name: </label>
                <input
                    type="text"
                    value={name}
                    onChange={(e) => setName(e.target.value)}
                />
            </div>
            <div>
                <label>Email: </label>
                <input
                    type="email"
                    value={email}
                    onChange={(e) => setEmail(e.target.value)}
                />
            </div>
            <button type="submit">Submit</button>
        </form>
    );
}

// 5. Conditional rendering
function WelcomeMessage({ isLoggedIn }) {
    return (
        <div>
            {isLoggedIn ? (
                <h1>Welcome back!</h1>
            ) : (
                <h1>Please sign in</h1>
            )}
        </div>
    );
}

// 6. List rendering
function TodoList() {
    const todos = [
        { id: 1, text: 'Learn React', completed: false },
        { id: 2, text: 'Build a project', completed: false },
        { id: 3, text: 'Deploy to production', completed: true }
    ];

    return (
        <ul>
            {todos.map(todo => (
                <li key={todo.id} style={{
                    textDecoration: todo.completed ? 'line-through' : 'none'
                }}>
                    {todo.text}
                </li>
            ))}
        </ul>
    );
}

// 7. Event handling
function ButtonExample() {
    const handleClick = () => {
        alert('Button clicked!');
    };

    const handleMouseOver = () => {
        console.log('Mouse over button');
    };

    return (
        <div>
            <button onClick={handleClick}>
                Click me
            </button>
            <button onMouseOver={handleMouseOver}>
                Hover over me
            </button>
        </div>
    );
}

// 8. Component with useEffect

function Timer() {
    const [seconds, setSeconds] = useState(0);

    useEffect(() => {
        const interval = setInterval(() => {
            setSeconds(seconds => seconds + 1);
        }, 1000);

        return () => clearInterval(interval);
    }, []);

    return (
        <div>
            <h1>Timer: {seconds}s</h1>
        </div>
    );
}

// 9. Fetching data with useEffect
function UserProfile({ userId }) {
    const [user, setUser] = useState(null);
    const [loading, setLoading] = useState(true);

    useEffect(() => {
        fetch(`https://jsonplaceholder.typicode.com/users/${userId}`)
            .then(response => response.json())
            .then(data => {
                setUser(data);
                setLoading(false);
            })
            .catch(error => {
                console.error('Error fetching user:', error);
                setLoading(false);
            });
    }, [userId]);

    if (loading) return <div>Loading...</div>;
    if (!user) return <div>User not found</div>;

    return (
        <div>
            <h2>{user.name}</h2>
            <p>Email: {user.email}</p>
            <p>Phone: {user.phone}</p>
            <p>Website: {user.website}</p>
        </div>
    );
}

// 10. Custom hook example
function useCounter(initialValue = 0) {
    const [count, setCount] = useState(initialValue);

    const increment = () => setCount(count + 1);
    const decrement = () => setCount(count - 1);
    const reset = () => setCount(initialValue);

    return { count, increment, decrement, reset };
}

function CustomCounter() {
    const { count, increment, decrement, reset } = useCounter(10);

    return (
        <div>
            <h1>Count: {count}</h1>
            <button onClick={increment}>+</button>
            <button onClick={decrement}>-</button>
            <button onClick={reset}>Reset</button>
        </div>
    );
}

// 11. Component composition
function Card({ title, children }) {
    return (
        <div style={{
            border: '1px solid #ccc',
            borderRadius: '8px',
            padding: '16px',
            margin: '16px'
        }}>
            <h3>{title}</h3>
            {children}
        </div>
    );
}

function App() {
    return (
        <div>
            <Card title="Welcome">
                <p>This is a card component with children.</p>
                <HelloWorld />
            </Card>
            <Card title="Counter">
                <Counter />
            </Card>
            <Card title="Timer">
                <Timer />
            </Card>
        </div>
    );
}

export {
    HelloWorld,
    Greeting,
    Counter,
    UserForm,
    WelcomeMessage,
    TodoList,
    ButtonExample,
    Timer,
    UserProfile,
    CustomCounter,
    Card,
    App
};
CodejavascriptIntermediate

Advanced React Hooks

Complex React hooks examples including useContext, useReducer, useMemo, and useCallback

Difficulty

7/10

Estimated time

35 min

Tags

react, hooks, state, performance

Prerequisites

React basics, JavaScript ES6+, State management concepts

javascript
// Advanced React Hooks Examples

import { useState, useContext, createContext, useReducer, useMemo, useCallback, useRef, useEffect } from 'react';

// 1. useContext Example
const ThemeContext = createContext();

function ThemeProvider({ children }) {
    const [theme, setTheme] = useState('light');

    const toggleTheme = () => {
        setTheme(prevTheme => prevTheme === 'light' ? 'dark' : 'light');
    };

    return (
        <ThemeContext.Provider value={{ theme, toggleTheme }}>
            {children}
        </ThemeContext.Provider>
    );
}

function ThemedComponent() {
    const { theme, toggleTheme } = useContext(ThemeContext);

    const styles = {
        backgroundColor: theme === 'light' ? '#fff' : '#333',
        color: theme === 'light' ? '#333' : '#fff',
        padding: '20px',
        borderRadius: '8px'
    };

    return (
        <div style={styles}>
            <h2>Current Theme: {theme}</h2>
            <button onClick={toggleTheme}>Toggle Theme</button>
        </div>
    );
}

// 2. useReducer Example
const initialState = {
    count: 0,
    history: []
};

function counterReducer(state, action) {
    switch (action.type) {
        case 'increment':
            return {
                count: state.count + 1,
                history: [...state.history, `Increment to ${state.count + 1}`]
            };
        case 'decrement':
            return {
                count: state.count - 1,
                history: [...state.history, `Decrement to ${state.count - 1}`]
            };
        case 'reset':
            return {
                count: 0,
                history: []
            };
        default:
            return state;
    }
}

function CounterWithReducer() {
    const [state, dispatch] = useReducer(counterReducer, initialState);

    return (
        <div>
            <h1>Count: {state.count}</h1>
            <button onClick={() => dispatch({ type: 'increment' })}>
                +
            </button>
            <button onClick={() => dispatch({ type: 'decrement' })}>
                -
            </button>
            <button onClick={() => dispatch({ type: 'reset' })}>
                Reset
            </button>
            <h3>History:</h3>
            <ul>
                {state.history.map((item, index) => (
                    <li key={index}>{item}</li>
                ))}
            </ul>
        </div>
    );
}

// 3. useMemo Example
function ExpensiveComponent({ number }) {
    const expensiveCalculation = useMemo(() => {
        console.log('Running expensive calculation...');
        let result = 0;
        for (let i = 0; i < number * 1000000; i++) {
            result += Math.sqrt(i);
        }
        return Math.round(result);
    }, [number]);

    return (
        <div>
            <h3>Expensive Calculation Result: {expensiveCalculation}</h3>
            <p>Input number: {number}</p>
        </div>
    );
}

// 4. useCallback Example
function ParentComponent() {
    const [count, setCount] = useState(0);

    const handleClick = useCallback(() => {
        console.log('Button clicked! Count:', count);
    }, [count]);

    return (
        <div>
            <h1>Count: {count}</h1>
            <button onClick={() => setCount(count + 1)}>
                Increment
            </button>
            <ChildButton onClick={handleClick} />
        </div>
    );
}

// Memoized child component
const ChildButton = React.memo(({ onClick }) => {
    console.log('ChildButton rendered');
    return <button onClick={onClick}>Child Button</button>;
});

// 5. useRef Example
function RefExample() {
    const inputRef = useRef(null);
    const countRef = useRef(0);

    const focusInput = () => {
        inputRef.current.focus();
    };

    const incrementRef = () => {
        countRef.current += 1;
        console.log('Ref count:', countRef.current);
    };

    return (
        <div>
            <input ref={inputRef} type="text" placeholder="Focus me" />
            <button onClick={focusInput}>Focus Input</button>
            <button onClick={incrementRef}>Increment Ref</button>
        </div>
    );
}

// 6. Custom Hook: useLocalStorage
function useLocalStorage(key, initialValue) {
    const [storedValue, setStoredValue] = useState(() => {
        try {
            const item = window.localStorage.getItem(key);
            return item ? JSON.parse(item) : initialValue;
        } catch (error) {
            console.error('Error reading localStorage:', error);
            return initialValue;
        }
    });

    const setValue = useCallback((value) => {
        try {
            const valueToStore = value instanceof Function ? value(storedValue) : value;
            setStoredValue(valueToStore);
            window.localStorage.setItem(key, JSON.stringify(valueToStore));
        } catch (error) {
            console.error('Error setting localStorage:', error);
        }
    }, [key, storedValue]);

    return [storedValue, setValue];
}

function LocalStorageExample() {
    const [name, setName] = useLocalStorage('userName', '');

    return (
        <div>
            <input
                type="text"
                value={name}
                onChange={(e) => setName(e.target.value)}
                placeholder="Enter your name"
            />
            <p>Your name: {name}</p>
            <p>(Persisted in localStorage)</p>
        </div>
    );
}

// 7. Custom Hook: useDebounce
function useDebounce(value, delay) {
    const [debouncedValue, setDebouncedValue] = useState(value);

    useEffect(() => {
        const handler = setTimeout(() => {
            setDebouncedValue(value);
        }, delay);

        return () => {
            clearTimeout(handler);
        };
    }, [value, delay]);

    return debouncedValue;
}

function SearchExample() {
    const [searchTerm, setSearchTerm] = useState('');
    const debouncedSearchTerm = useDebounce(searchTerm, 500);

    useEffect(() => {
        if (debouncedSearchTerm) {
            console.log('Searching for:', debouncedSearchTerm);
            // In real app, this would trigger an API call
        }
    }, [debouncedSearchTerm]);

    return (
        <div>
            <input
                type="text"
                value={searchTerm}
                onChange={(e) => setSearchTerm(e.target.value)}
                placeholder="Search..."
            />
            <p>Debounced search term: {debouncedSearchTerm}</p>
        </div>
    );
}

// 8. useLayoutEffect Example
function LayoutEffectExample() {
    const [dimensions, setDimensions] = useState({ width: 0, height: 0 });
    const divRef = useRef(null);

    useLayoutEffect(() => {
        if (divRef.current) {
            const { clientWidth, clientHeight } = divRef.current;
            setDimensions({ width: clientWidth, height: clientHeight });
        }
    }, []);

    return (
        <div>
            <div
                ref={divRef}
                style={{
                    width: '300px',
                    height: '200px',
                    backgroundColor: 'lightblue',
                    padding: '20px'
                }}
            >
                <h3>Component with Layout Effect</h3>
                <p>Width: {dimensions.width}px</p>
                <p>Height: {dimensions.height}px</p>
            </div>
        </div>
    );
}

// 9. useImperativeHandle Example (with forwardRef)
const CustomInput = React.forwardRef((props, ref) => {
    const inputRef = useRef(null);

    useImperativeHandle(ref, () => ({
        focus: () => {
            inputRef.current.focus();
        },
        clear: () => {
            inputRef.current.value = '';
        },
        getValue: () => {
            return inputRef.current.value;
        }
    }));

    return <input ref={inputRef} type="text" {...props} />;
});

function ImperativeHandleExample() {
    const inputRef = useRef(null);

    const handleFocus = () => {
        inputRef.current.focus();
    };

    const handleClear = () => {
        inputRef.current.clear();
    };

    const handleGetValue = () => {
        alert(`Input value: ${inputRef.current.getValue()}`);
    };

    return (
        <div>
            <CustomInput ref={inputRef} placeholder="Type something..." />
            <button onClick={handleFocus}>Focus</button>
            <button onClick={handleClear}>Clear</button>
            <button onClick={handleGetValue}>Get Value</button>
        </div>
    );
}

// 10. Combination Example: Todo App with multiple hooks
const initialState = {
    todos: [],
    filter: 'all'
};

function todosReducer(state, action) {
    switch (action.type) {
        case 'add':
            return {
                ...state,
                todos: [...state.todos, {
                    id: Date.now(),
                    text: action.text,
                    completed: false
                }]
            };
        case 'toggle':
            return {
                ...state,
                todos: state.todos.map(todo =>
                    todo.id === action.id
                        ? { ...todo, completed: !todo.completed }
                        : todo
                )
            };
        case 'delete':
            return {
                ...state,
                todos: state.todos.filter(todo => todo.id !== action.id)
            };
        case 'setFilter':
            return { ...state, filter: action.filter };
        default:
            return state;
    }
}

function TodoApp() {
    const [state, dispatch] = useReducer(todosReducer, initialState);
    const [inputText, setInputText] = useState('');

    const filteredTodos = useMemo(() => {
        switch (state.filter) {
            case 'completed':
                return state.todos.filter(todo => todo.completed);
            case 'active':
                return state.todos.filter(todo => !todo.completed);
            default:
                return state.todos;
        }
    }, [state.todos, state.filter]);

    const addTodo = useCallback((text) => {
        if (text.trim()) {
            dispatch({ type: 'add', text: text.trim() });
            setInputText('');
        }
    }, []);

    const handleSubmit = (e) => {
        e.preventDefault();
        addTodo(inputText);
    };

    return (
        <div>
            <h1>Todo App</h1>
            <form onSubmit={handleSubmit}>
                <input
                    value={inputText}
                    onChange={(e) => setInputText(e.target.value)}
                    placeholder="Add new todo..."
                />
                <button type="submit">Add</button>
            </form>

            <div>
                <button onClick={() => dispatch({ type: 'setFilter', filter: 'all' })}>
                    All
                </button>
                <button onClick={() => dispatch({ type: 'setFilter', filter: 'active' })}>
                    Active
                </button>
                <button onClick={() => dispatch({ type: 'setFilter', filter: 'completed' })}>
                    Completed
                </button>
            </div>

            <ul>
                {filteredTodos.map(todo => (
                    <li key={todo.id}>
                        <input
                            type="checkbox"
                            checked={todo.completed}
                            onChange={() => dispatch({ type: 'toggle', id: todo.id })}
                        />
                        <span style={{
                            textDecoration: todo.completed ? 'line-through' : 'none'
                        }}>
                            {todo.text}
                        </span>
                        <button onClick={() => dispatch({ type: 'delete', id: todo.id })}>
                            Delete
                        </button>
                    </li>
                ))}
            </ul>
        </div>
    );
}

export {
    ThemeProvider,
    ThemedComponent,
    CounterWithReducer,
    ExpensiveComponent,
    ParentComponent,
    RefExample,
    LocalStorageExample,
    SearchExample,
    LayoutEffectExample,
    ImperativeHandleExample,
    TodoApp
};
CodejavascriptComplex

React Design Patterns

Common React patterns including Higher-Order Components, Render Props, and Compound Components

Difficulty

9/10

Estimated time

45 min

Tags

react, patterns, architecture, advanced

Prerequisites

Advanced React, JavaScript ES6+, Component patterns

javascript
// React Design Patterns

import { useState, createContext, useContext } from 'react';

// 1. Higher-Order Component (HOC) Pattern
function withLogging(WrappedComponent) {
    return function WithLoggingComponent(props) {
        console.log(`Rendering ${WrappedComponent.name}`, props);

        return <WrappedComponent {...props} />;
    };
}

function SimpleComponent({ name }) {
    return <h1>Hello, {name}!</h1>;
}

const LoggedComponent = withLogging(SimpleComponent);

// 2. HOC with additional functionality
function withCounter(WrappedComponent) {
    return function WithCounterComponent(props) {
        const [count, setCount] = useState(0);

        return (
            <WrappedComponent
                {...props}
                count={count}
                increment={() => setCount(count + 1)}
                decrement={() => setCount(count - 1)}
            />
        );
    };
}

function CounterDisplay({ count, increment, decrement }) {
    return (
        <div>
            <h2>Count: {count}</h2>
            <button onClick={increment}>+</button>
            <button onClick={decrement}>-</button>
        </div>
    );
}

const EnhancedCounter = withCounter(CounterDisplay);

// 3. Render Props Pattern
class MouseTracker extends React.Component {
    state = { x: 0, y: 0 };

    handleMouseMove = (event) => {
        this.setState({
            x: event.clientX,
            y: event.clientY
        });
    };

    render() {
        return (
            <div style={{ height: '200px', border: '1px solid #ccc' }} onMouseMove={this.handleMouseMove}>
                {this.props.render(this.state)}
            </div>
        );
    }
}

function MouseDisplay() {
    return (
        <MouseTracker
            render={({ x, y }) => (
                <div>
                    <h3>Mouse Position:</h3>
                    <p>X: {x}, Y: {y}</p>
                </div>
            )}
        />
    );
}

// 4. Render Props with children
function MouseTrackerChildren({ children }) {
    const [position, setPosition] = useState({ x: 0, y: 0 });

    const handleMouseMove = (e) => {
        setPosition({ x: e.clientX, y: e.clientY });
    };

    return (
        <div style={{ height: '200px', border: '1px solid #ccc' }} onMouseMove={handleMouseMove}>
            {children(position)}
        </div>
    );
}

function MouseDisplayChildren() {
    return (
        <MouseTrackerChildren>
            {({ x, y }) => (
                <div>
                    <h3>Mouse Position (Children):</h3>
                    <p>X: {x}, Y: {y}</p>
                </div>
            )}
        </MouseTrackerChildren>
    );
}

// 5. Compound Components Pattern
const TabsContext = createContext();

function Tabs({ children, defaultTab = 0 }) {
    const [activeTab, setActiveTab] = useState(defaultTab);

    return (
        <TabsContext.Provider value={{ activeTab, setActiveTab }}>
            <div className="tabs">{children}</div>
        </TabsContext.Provider>
    );
}

function TabList({ children }) {
    return <div className="tab-list">{children}</div>;
}

function Tab({ children, index }) {
    const { activeTab, setActiveTab } = useContext(TabsContext);

    return (
        <button
            className={`tab ${activeTab === index ? 'active' : ''}`}
            onClick={() => setActiveTab(index)}
        >
            {children}
        </button>
    );
}

function TabPanels({ children }) {
    return <div className="tab-panels">{children}</div>;
}

function TabPanel({ children, index }) {
    const { activeTab } = useContext(TabsContext);

    return activeTab === index ? <div className="tab-panel">{children}</div> : null;
}

// Usage of Compound Components
function CompoundComponentExample() {
    return (
        <Tabs defaultTab={0}>
            <TabList>
                <Tab index={0}>Tab 1</Tab>
                <Tab index={1}>Tab 2</Tab>
                <Tab index={2}>Tab 3</Tab>
            </TabList>
            <TabPanels>
                <TabPanel index={0}>Content for Tab 1</TabPanel>
                <TabPanel index={1}>Content for Tab 2</TabPanel>
                <TabPanel index={2}>Content for Tab 3</TabPanel>
            </TabPanels>
        </Tabs>
    );
}

// 6. Provider Pattern
const UserContext = createContext();

function UserProvider({ children }) {
    const [user, setUser] = useState(null);

    const login = (userData) => {
        setUser(userData);
    };

    const logout = () => {
        setUser(null);
    };

    return (
        <UserContext.Provider value={{ user, login, logout }}>
            {children}
        </UserContext.Provider>
    );
}

function useUser() {
    const context = useContext(UserContext);
    if (!context) {
        throw new Error('useUser must be used within a UserProvider');
    }
    return context;
}

function UserProfile() {
    const { user, logout } = useUser();

    if (!user) {
        return <div>Please log in</div>;
    }

    return (
        <div>
            <h2>Welcome, {user.name}!</h2>
            <p>Email: {user.email}</p>
            <button onClick={logout}>Logout</button>
        </div>
    );
}

// 7. State Reducer Pattern
function useToggle(initialState = false) {
    return useReducer((state, action) => {
        switch (action.type) {
            case 'toggle':
                return !state;
            case 'on':
                return true;
            case 'off':
                return false;
            default:
                throw new Error(`Unhandled action type: ${action.type}`);
        }
    }, initialState);
}

function ToggleButton({ onToggle }) {
    const [isOn, toggle] = useToggle();

    const handleClick = () => {
        toggle({ type: 'toggle' });
        onToggle && onToggle(isOn);
    };

    return (
        <button onClick={handleClick}>
            {isOn ? 'ON' : 'OFF'}
        </button>
    );
}

// 8. Control Props Pattern
function Toggle({ on, onChange, children }) {
    const [internalOn, setInternalOn] = useState(false);
    const isOn = on !== undefined ? on : internalOn;

    const handleClick = () => {
        const newOn = !isOn;
        if (onChange) {
            onChange(newOn);
        } else {
            setInternalOn(newOn);
        }
    };

    return (
        <button onClick={handleClick}>
            {children(isOn)}
        </button>
    );
}

function ControlPropsExample() {
    const [isOn, setIsOn] = useState(false);

    return (
        <div>
            <h3>Controlled Toggle:</h3>
            <Toggle on={isOn} onChange={setIsOn}>
                {(isOn) => (isOn ? 'Turn Off' : 'Turn On')}
            </Toggle>
            <p>State: {isOn ? 'ON' : 'OFF'}</p>

            <h3>Uncontrolled Toggle:</h3>
            <Toggle>
                {(isOn) => (isOn ? 'Switch Off' : 'Switch On')}
            </Toggle>
        </div>
    );
}

// 9. Custom Hook Pattern
function useAsync(asyncFn, dependencies = []) {
    const [state, setState] = useState({
        data: null,
        loading: false,
        error: null
    });

    useEffect(() => {
        let isCancelled = false;

        const runAsync = async () => {
            setState(prev => ({ ...prev, loading: true, error: null }));

            try {
                const result = await asyncFn();
                if (!isCancelled) {
                    setState({ data: result, loading: false, error: null });
                }
            } catch (error) {
                if (!isCancelled) {
                    setState({ data: null, loading: false, error });
                }
            }
        };

        runAsync();

        return () => {
            isCancelled = true;
        };
    }, dependencies);

    return state;
}

function AsyncComponent() {
    const { data, loading, error } = useAsync(async () => {
        const response = await fetch('https://jsonplaceholder.typicode.com/users/1');
        return response.json();
    }, []);

    if (loading) return <div>Loading...</div>;
    if (error) return <div>Error: {error.message}</div>;
    if (!data) return <div>No data</div>;

    return (
        <div>
            <h2>User Data:</h2>
            <p>Name: {data.name}</p>
            <p>Email: {data.email}</p>
            <p>Phone: {data.phone}</p>
        </div>
    );
}

// 10. Presentational vs Container Pattern
// Presentational Component
const UserListPresentational = ({ users, onUserSelect }) => (
    <ul>
        {users.map(user => (
            <li key={user.id} onClick={() => onUserSelect(user.id)}>
                {user.name}
            </li>
        ))}
    </ul>
);

// Container Component
function UserListContainer() {
    const [users, setUsers] = useState([]);
    const [selectedUser, setSelectedUser] = useState(null);

    useEffect(() => {
        fetch('https://jsonplaceholder.typicode.com/users')
            .then(response => response.json())
            .then(data => setUsers(data));
    }, []);

    const handleUserSelect = (userId) => {
        setSelectedUser(userId);
    };

    return (
        <div>
            <UserListPresentational
                users={users}
                onUserSelect={handleUserSelect}
            />
            {selectedUser && <p>Selected user ID: {selectedUser}</p>}
        </div>
    );
}

// Main App Component showing all patterns
function DesignPatternsApp() {
    const [user, login] = useState({ name: 'John Doe', email: 'john@example.com' });

    return (
        <div>
            <h1>React Design Patterns</h1>

            <section>
                <h2>HOC Pattern</h2>
                <LoggedComponent name="World" />
                <EnhancedCounter />
            </section>

            <section>
                <h2>Render Props Pattern</h2>
                <MouseDisplay />
                <MouseDisplayChildren />
            </section>

            <section>
                <h2>Compound Components</h2>
                <CompoundComponentExample />
            </section>

            <section>
                <h2>Provider Pattern</h2>
                <UserProvider>
                    <UserProfile />
                </UserProvider>
            </section>

            <section>
                <h2>Control Props Pattern</h2>
                <ControlPropsExample />
            </section>

            <section>
                <h2>Custom Hook Pattern</h2>
                <AsyncComponent />
            </section>

            <section>
                <h2>Container/Presentational Pattern</h2>
                <UserListContainer />
            </section>
        </div>
    );
}

export {
    withLogging,
    withCounter,
    LoggedComponent,
    EnhancedCounter,
    MouseTracker,
    MouseDisplay,
    Tabs,
    TabList,
    Tab,
    TabPanels,
    TabPanel,
    UserProvider,
    useUser,
    UserProfile,
    useToggle,
    ToggleButton,
    Toggle,
    ControlPropsExample,
    useAsync,
    AsyncComponent,
    UserListPresentational,
    UserListContainer,
    DesignPatternsApp
};

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

Development

AI Regex Explainer

Use AI to break down regular expressions into readable explanations

Data Processing

Array Analyzer

Comprehensive array analysis tool with statistics, data types, and frequency analysis

Media

Batch Audio Rename

Batch rename audio files using patterns, text replacement, numbering, and case conversion. Returns renamed files as a ZIP download.

Development

Glob to Regex

Convert file matching patterns (Glob) to regular expressions

Design

Add Texture Effect

Add various texture overlays to images with customizable blend modes and intensity

Media

Batch Image Rename

Batch rename image files using patterns, text replacement, numbering, and case conversion. Returns renamed files as a ZIP download.

Security

JWT Generator

Generate JWT tokens with custom claims and algorithms

Development

Multi-Pattern Matcher

Match multiple regex patterns against text in one operation

Web Frameworks

Preact Samples

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

CSS Frameworks

Bulma CSS Framework Samples

Bulma CSS framework examples including columns, components, form controls, layout system, and modern CSS-based design patterns

Web Frameworks

Elysia.js Samples

Elysia.js modern TypeScript web framework examples including Hello World, routing, validation, and plugin development

Web Frameworks

Koa Samples

Koa Node.js middleware framework examples including middleware chaining, context handling, async/await patterns, and ecosystem integration

Web Frameworks

Fastify Samples

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

Media

Copyright-Free MP3 Audio Samples

Collection of royalty-free audio samples for testing and development purposes including nature sounds, meditation music, and ambient audio