Elysia Tools

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

Top Categories

Hubs

Language
ZHDERUPTENFRES

Elysia Tools

Navigation

Development

Code Documentation Samples

Code samples with various documentation styles including JSDoc, JavaDoc, Python docstrings, and TypeScript annotations

Samples

Entries inside this sample collection

TextjavascriptSimple

JavaScript Functions with JSDoc

Well-documented JavaScript functions using JSDoc standard

Difficulty

3/10

Estimated time

3 min

Tags

javascript, jsdoc, functions

javascript
/**
 * Calculates the factorial of a non-negative integer.
 *
 * @param {number} n - The non-negative integer to calculate factorial for
 * @returns {number} The factorial of n
 * @throws {RangeError} If n is negative or not an integer
 * @example
 * factorial(5) // returns 120
 * factorial(0) // returns 1
 */
function factorial(n) {
  if (!Number.isInteger(n) || n < 0) {
    throw new RangeError('n must be a non-negative integer');
  }
  if (n === 0 || n === 1) {
    return 1;
  }
  return n * factorial(n - 1);
}

/**
 * Formats a date into a human-readable string.
 *
 * @param {Date} date - The date object to format
 * @param {string} [format="ISO"] - The format style: "ISO", "US", or "EU"
 * @param {boolean} [includeTime=true] - Whether to include time in the output
 * @returns {string} The formatted date string
 * @example
 * formatDate(new Date(), "US", false) // returns "12/25/2024"
 */
function formatDate(date, format = 'ISO', includeTime = true) {
  const options = {
    year: 'numeric',
    month: format === 'US' ? 'numeric' : '2-digit',
    day: '2-digit',
    hour: includeTime ? '2-digit' : undefined,
    minute: includeTime ? '2-digit' : undefined
  };
  return date.toLocaleDateString(format === 'US' ? 'en-US' : 'en-GB', options);
}
TextjavascriptIntermediate

JavaScript Class with JSDoc

JavaScript class with comprehensive JSDoc documentation

Difficulty

4/10

Estimated time

4 min

Tags

javascript, jsdoc, class, oop

javascript
/**
 * Represents a user account with authentication capabilities.
 *
 * @class User
 * @example
 * const user = new User('john@example.com', 'password123');
 * await user.authenticate();
 */
class User {
  /**
   * Creates an instance of User.
   *
   * @param {string} email - The user's email address
   * @param {string} password - The user's password (will be hashed)
   */
  constructor(email, password) {
    /**
     * @type {string}
     * @readonly
     */
    this.email = email;
    /**
     * @type {string}
     * @private
     */
    this._passwordHash = this._hashPassword(password);
    /**
     * @type {Date}
     */
    this.createdAt = new Date();
  }

  /**
   * Hashes a password using SHA-256.
   *
   * @private
   * @param {string} password - The plain text password
   * @returns {string} The hashed password
   */
  _hashPassword(password) {
    // Implementation simplified for example
    return 'hashed_' + password;
  }

  /**
   * Authenticates the user with the provided credentials.
   *
   * @async
   * @param {string} password - The password to verify
   * @returns {Promise<boolean>} True if authentication successful
   * @throws {AuthenticationError} If authentication fails
   */
  async authenticate(password) {
    const hash = this._hashPassword(password);
    return hash === this._passwordHash;
  }

  /**
   * Updates the user's email address.
   *
   * @param {string} newEmail - The new email address
   * @throws {ValidationError} If email is invalid
   */
  updateEmail(newEmail) {
    if (!this._isValidEmail(newEmail)) {
      throw new Error('Invalid email format');
    }
    this.email = newEmail;
  }
}
TexttypescriptIntermediate

TypeScript Interface with JSDoc

TypeScript interface enriched with JSDoc annotations

Difficulty

4/10

Estimated time

4 min

Tags

typescript, interface, jsdoc, types

typescript
/**
 * Represents the configuration options for an API client.
 *
 * @interface ApiClientConfig
 */
interface ApiClientConfig {
  /**
   * The base URL for all API requests.
   *
   * @type {string}
   * @example "https://api.example.com"
   */
  baseUrl: string;

  /**
   * Authentication token for API requests.
   *
   * @type {string}
   * @optional
   */
  authToken?: string;

  /**
   * Request timeout in milliseconds.
   *
   * @type {number}
   * @default 5000
   */
  timeout?: number;

  /**
   * Number of retry attempts for failed requests.
   *
   * @type {number}
   * @default 3
   */
  retries?: number;

  /**
   * Enable debug logging.
   *
   * @type {boolean}
   * @default false
   */
  debug?: boolean;
}

/**
 * Response data structure from the API.
 *
 * @interface ApiResponse
 * @template T - The type of data returned
 */
interface ApiResponse<T> {
  /**
   * HTTP status code.
   *
   * @type {number}
   */
  status: number;

  /**
   * Response message.
   *
   * @type {string}
   */
  message: string;

  /**
   * The payload data.
   *
   * @type {T}
   */
  data: T;
}
TexttypescriptIntermediate

TypeScript Class with Full Documentation

TypeScript class with types and comprehensive JSDoc

Difficulty

5/10

Estimated time

5 min

Tags

typescript, class, generics, data-structure

typescript
/**
 * Generic stack implementation with type safety.
 *
 * @template T - The type of elements in the stack
 * @example
 * const stack = new Stack<number>();
 * stack.push(1);
 * stack.push(2);
 * console.log(stack.pop()); // 2
 */
class Stack<T> {
  private items: T[] = [];

  /**
   * Creates an empty stack.
   */
  constructor() {}

  /**
   * Adds an element to the top of the stack.
   *
   * @param {T} item - The element to add
   * @returns {void}
   * @example
   * stack.push('item');
   */
  push(item: T): void {
    this.items.push(item);
  }

  /**
   * Removes and returns the top element from the stack.
   *
   * @returns {T | undefined} The removed element, or undefined if stack is empty
   * @throws {Error} If the stack is empty
   * @example
   * const item = stack.pop();
   */
  pop(): T | undefined {
    if (this.isEmpty()) {
      throw new Error('Stack is empty');
    }
    return this.items.pop();
  }

  /**
   * Returns the top element without removing it.
   *
   * @returns {T | undefined} The top element, or undefined if stack is empty
   * @example
   * const top = stack.peek();
   */
  peek(): T | undefined {
    return this.items[this.items.length - 1];
  }

  /**
   * Checks if the stack is empty.
   *
   * @returns {boolean} True if stack is empty, false otherwise
   */
  isEmpty(): boolean {
    return this.items.length === 0;
  }

  /**
   * Returns the number of elements in the stack.
   *
   * @returns {number} The size of the stack
   */
  size(): number {
    return this.items.length;
  }
}
TextpythonSimple

Python Functions with Docstrings

Python functions following Google style docstrings

Difficulty

3/10

Estimated time

3 min

Tags

python, docstring, functions, google-style

python
def calculate_bmi(weight: float, height: float) -> float:
    """Calculate Body Mass Index (BMI).

    BMI is a measure of body fat based on height and weight.
    Formula: weight (kg) / height (m)^2

    Args:
        weight: Weight in kilograms. Must be positive.
        height: Height in meters. Must be positive.

    Returns:
        The BMI value as a float.

    Raises:
        ValueError: If weight or height is not positive.

    Examples:
        >>> calculate_bmi(70, 1.75)
        22.857...
        >>> calculate_bmi(80, 1.80)
        24.691...
    """
    if weight <= 0 or height <= 0:
        raise ValueError("Weight and height must be positive")

    return weight / (height ** 2)


def format_name(first: str, last: str, middle: str = "") -> str:
    """Format a full name from given parts.

    Args:
        first: First name
        last: Last name
        middle: Middle name (optional)

    Returns:
        Formatted full name

    Examples:
        >>> format_name("John", "Doe")
        'John Doe'
        >>> format_name("Jane", "Smith", "Marie")
        'Jane Marie Smith'
    """
    parts = [first, middle, last] if middle else [first, last]
    return " ".join(parts)
TextpythonIntermediate

Python Class with Docstrings

Python class with comprehensive docstring documentation

Difficulty

4/10

Estimated time

4 min

Tags

python, docstring, class, banking

python
class BankAccount:
    """A simple bank account class.

    This class provides basic banking operations including deposits,
    withdrawals, and balance inquiries.

    Attributes:
        account_number (str): Unique account identifier
        balance (float): Current account balance
        owner (str): Name of the account owner

    Examples:
        >>> account = BankAccount("12345", "John Doe")
        >>> account.deposit(100)
        >>> account.get_balance()
        100.0
    """

    def __init__(self, account_number: str, owner: str, initial_balance: float = 0):
        """Initialize a new bank account.

        Args:
            account_number: Unique account identifier
            owner: Name of the account owner
            initial_balance: Starting balance (default: 0)

        Raises:
            ValueError: If initial_balance is negative
        """
        self.account_number = account_number
        self.owner = owner
        self.balance = initial_balance

    def deposit(self, amount: float) -> bool:
        """Deposit money into the account.

        Args:
            amount: Amount to deposit (must be positive)

        Returns:
            True if deposit successful

        Raises:
            ValueError: If amount is not positive
        """
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.balance += amount
        return True

    def withdraw(self, amount: float) -> bool:
        """Withdraw money from the account.

        Args:
            amount: Amount to withdraw (must be positive)

        Returns:
            True if withdrawal successful

        Raises:
            ValueError: If amount is invalid or insufficient funds
        """
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        return True

    def get_balance(self) -> float:
        """Get the current account balance.

        Returns:
            Current balance as a float
        """
        return self.balance
TextjavaIntermediate

Java Class with JavaDoc

Java class with complete JavaDoc documentation

Difficulty

4/10

Estimated time

4 min

Tags

java, javadoc, class, http

java
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

/**
 * Represents a simplified HTTP response with status, headers, and body.
 *
 * <p>This class encapsulates the components of an HTTP response and provides
 * methods to access and modify them.
 *
 * @author Elysia Tools
 * @version 1.0
 * @since 1.0
 *
 * @see HttpClient
 * @see HttpRequest
 */
public class HttpResponse {

  /** The HTTP status code (e.g., 200, 404, 500) */
  private int statusCode;

  /** The response body content */
  private String body;

  /** Response headers as key-value pairs */
  private Map<String, String> headers;

  /**
   * Constructs a new HttpResponse with the specified status code.
   *
   * @param statusCode the HTTP status code (must be between 100 and 599)
   * @throws IllegalArgumentException if statusCode is invalid
   */
  public HttpResponse(int statusCode) {
    setStatusCode(statusCode);
    this.body = "";
    this.headers = new HashMap<>();
  }

  /**
   * Constructs a new HttpResponse with status code and body.
   *
   * @param statusCode the HTTP status code
   * @param body the response body content
   */
  public HttpResponse(int statusCode, String body) {
    this(statusCode);
    this.body = body;
  }

  /**
   * Gets the HTTP status code.
   *
   * @return the status code
   */
  public int getStatusCode() {
    return statusCode;
  }

  /**
   * Sets the HTTP status code.
   *
   * @param statusCode the new status code (100-599)
   * @throws IllegalArgumentException if status code is out of range
   */
  public void setStatusCode(int statusCode) {
    if (statusCode < 100 || statusCode > 599) {
      throw new IllegalArgumentException("Invalid status code: " + statusCode);
    }
    this.statusCode = statusCode;
  }

  /**
   * Gets the response body.
   *
   * @return the body content, or empty string if not set
   */
  public String getBody() {
    return body;
  }

  /**
   * Sets the response body.
   *
   * @param body the new body content (can be null, will be converted to empty string)
   */
  public void setBody(String body) {
    this.body = Objects.toStringElse(body, "");
  }

  /**
   * Checks if the response indicates success (status code 2xx).
   *
   * @return true if status code is between 200 and 299
   */
  public boolean isSuccess() {
    return statusCode >= 200 && statusCode < 300;
  }
} 
TextjavaSimple

Java Method with Full JavaDoc

Java method with comprehensive JavaDoc annotations

Difficulty

3/10

Estimated time

3 min

Tags

java, javadoc, method, validation

java
/**
 * Validates and formats a phone number according to international standards.
 *
 * <p>This method accepts a phone number in various formats and returns
 * a standardized E.164 format. It handles country codes, area codes, and
 * validates the number structure.
 *
 * @param phoneNumber the phone number to validate and format
 *        (can include spaces, dashes, parentheses)
 * @param countryCode the ISO 3166-1 alpha-2 country code
 *        (e.g., "US", "GB", "FR")
 *
 * @return the formatted phone number in E.164 format
 *         (e.g., "+14155552671")
 *
 * @throws IllegalArgumentException if {@code phoneNumber} is null or empty
 * @throws IllegalArgumentException if {@code countryCode} is not a valid ISO code
 * @throws NumberFormatException if the phone number contains invalid characters
 *
 * @see <a href="https://en.wikipedia.org/wiki/E.164">E.164 Specification</a>
 *
 * @since 1.0
 *
 * @deprecated Use {@link PhoneNumberUtil#parse(String, String)} instead
 */
@Deprecated
public static String formatPhoneNumber(String phoneNumber, String countryCode) {
  // Implementation details...
  return null;
}

/**
 * Calculates the compound interest over a given period.
 *
 * <p>Formula: A = P(1 + r/n)^(nt)<br>
 * Where A = final amount, P = principal, r = annual rate,<br>
 * n = times compounded per year, t = years
 *
 * @param principal the initial investment amount (must be positive)
 * @param annualRate the annual interest rate as decimal (e.g., 0.05 for 5%)
 * @param timesPerYear number of times interest is compounded per year
 * @param years the investment period in years
 *
 * @return the final amount including compound interest
 *
 * @throws IllegalArgumentException if any parameter is invalid
 *
 * @see Math#pow(double, double)
 */
public static double calculateCompoundInterest(
  double principal,
  double annualRate,
  int timesPerYear,
  int years) {
  // Implementation details...
  return 0.0;
} 
TexttypescriptComplex

Code with Mixed Documentation Tags

Complex example with various documentation annotation tags

Difficulty

6/10

Estimated time

6 min

Tags

typescript, mixed, annotations, complex

typescript
/**
 * Advanced data processor with transformation and validation capabilities.
 *
 * @template TInput - Input data type
 * @template TOutput - Output data type
 *
 * @example
 * const processor = new DataProcessor<string, number>({
 *   transform: (str) => parseInt(str),
 *   validate: (num) => !isNaN(num)
 * });
 */
class DataProcessor<TInput, TOutput> {
  /**
   * Processing options configuration.
   *
   * @typedef {Object} ProcessorOptions
   * @property {Function} transform - Transform function
   * @property {Function} validate - Validation function
   * @property {boolean} [async=false] - Enable async processing
   * @property {number} [maxRetries=3] - Maximum retry attempts
   */
  private options: ProcessorOptions;

  /**
   * Creates a new data processor instance.
   *
   * @param {ProcessorOptions} options - Configuration options
   * @throws {TypeError} If options is invalid
   */
  constructor(options: ProcessorOptions) {
    this.options = options;
  }

  /**
   * Processes input data through transformation and validation.
   *
   * @async
   * @param {TInput} data - Input data to process
   * @param {Object} [context] - Optional processing context
   * @param {string} [context.traceId] - Trace ID for logging
   * @returns {Promise<TOutput>} Processed output data
   * @throws {ValidationError} If validation fails
   * @throws {ProcessingError} If transformation fails
   *
   * @example
   * const result = await processor.process("123", { traceId: "abc123" });
   */
  async process(data: TInput, context?: { traceId?: string }): Promise<TOutput> {
    // Implementation...
    return {} as TOutput;
  }
} 
TexttypescriptComplex

Multi-line Documentation with Examples

Code with extensive multi-line documentation and code examples

Difficulty

6/10

Estimated time

6 min

Tags

typescript, multiline, examples, algorithm

typescript
/**
 * Binary search implementation for sorted arrays.
 *
 * <p>This method performs a binary search on a sorted array to find
 * the index of a target value. Binary search has O(log n) time complexity.
 *
 * <h3>Algorithm Steps:</h3>
 * <ol>
 *   <li>Initialize low = 0, high = array length - 1</li>
 *   <li>While low <= high:
 *     <ul>
 *       <li>Calculate mid = low + (high - low) / 2</li>
 *       <li>If array[mid] == target, return mid</li>
 *       <li>If array[mid] < target, low = mid + 1</li>
 *       <li>Else, high = mid - 1</li>
 *     </ul>
 *   </li>
 *   <li>If not found, return -1</li>
 * </ol>
 *
 * <h3>Usage Examples:</h3>
 * <pre><code>
 * // Basic usage
 * const arr = [1, 3, 5, 7, 9, 11];
 * binarySearch(arr, 7);  // returns 3
 *
 * // Element not found
 * binarySearch(arr, 4);  // returns -1
 *
 * // Empty array
 * binarySearch([], 5);   // returns -1
 * </code></pre>
 *
 * @param {number[]} array - The sorted array to search (must be sorted ascending)
 * @param {number} target - The value to find
 * @returns {number} The index of the target, or -1 if not found
 *
 * @throws {TypeError} If array is not an array or contains non-numeric values
 *
 * @see {@link https://en.wikipedia.org/wiki/Binary_search_algorithm|Binary Search on Wikipedia}
 * @see {@link linearSearch} for unsorted arrays
 *
 * @example
 * // Find index of value 5
 * const index = binarySearch([1, 2, 3, 4, 5], 5);
 * console.log(index); // Output: 4
 *
 * @author Elysia Development Team
 * @version 1.2.0
 * @since 1.0.0
 * @readonly
 */
function binarySearch(array: number[], target: number): number {
  if (!Array.isArray(array) || array.some(item => typeof item !== 'number')) {
    throw new TypeError('First argument must be an array of numbers');
  }

  let low = 0;
  let high = array.length - 1;

  while (low <= high) {
    const mid = Math.floor(low + (high - low) / 2);

    if (array[mid] === target) {
      return mid;
    }

    if (array[mid] < target) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }

  return -1;
} 

Tools

Tools frequently paired with this sample

Related

Related sample collections

Related

Related workflows

Hub

Documentation Authoring, Review, and Publishing

Extract source material from code, PDF, or HTML, then assemble, review, preview, and export a publishable documentation set.

Hub

Audio Master Lossy Codec Preflight and Delivery Checks

Preview a finished master through lossy encoding, inspect decoded peak and loudness changes, adjust only when necessary, and verify the exact final MP3, AAC or Opus delivery file.

Hub

Video Container Conversion with Deliberate Transcode Control

Convert footage between MP4, AVI, FLV, MKV, MOV, and WebM containers, keep CRF and bitrate decisions under control during the re-encode, and batch a whole library under one recorded configuration.

Hub

Barcode and QR Code Workflow

Create, decode, validate, verify, and print barcodes or QR codes for products, links, WiFi, and labels.

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

Design

QR Code Decoder

Decode QR codes from images and extract the contained text or URLs

Design

QR Code Art, Styled Module and Logo Embed Generator

Generate art QR codes with brand colors, gradients, rounded or dot modules and a centered logo, plus the ISO mask-penalty breakdown, per-module metadata export and a Reed–Solomon erasure-budget verdict.

Development

Code Comment Remover

Remove single-line (//...) and multi-line (/*...*/) comments from code

Development

Stripe Candidate Code & Import Script Generator

Generate candidate strings, a CSV template and a local Node.js importer. This website does not create codes in Stripe or track redemptions. Running the importer needs your Stripe API key on your own machine.

Development

Docstring Extractor

Extract and parse documentation from JavaScript/TypeScript, Python, and Java source code

Development

Gray Code and Thermometer BCD Encoder Visualizer

Convert an N-bit value to binary, Gray, one-hot and thermometer codes with a counting truth table, Hamming-distance chart and Verilog/VHDL encoder stubs.

Data Processing

VBA Code Formatter

Format and beautify VBA code for better readability

Development

Code Formatter

Format code in various languages

Code Processing

Code Comment Samples

Sample code files with various comment styles for testing comment removal

Development

Import Path Examples

Collection of JavaScript and TypeScript import examples demonstrating various import patterns and module systems

Development

Python Viewer Samples

Sample Python source files (classes, dataclasses, async/await) for the in-browser Python Viewer

Testing

Jest Testing Framework

Comprehensive Jest testing examples including unit tests, integration tests, mocking, async testing, and advanced patterns for JavaScript/TypeScript applications

Document

PDF Samples

Generated PDF samples from tools dated 2026-02-01 to 2026-02-10

Testing

Playwright E2E Testing Framework

Comprehensive Playwright testing examples including cross-browser automation, API testing, mobile testing, visual regression, and advanced E2E patterns for modern web applications