Toggle

toggle

Day 21: Custom Toggle Button, anyone? ⚙️ Today, we’re going to create a custom toggle button in SwiftUI. Implementing a Custom Toggle Button In this example, we’ll create a visually appealing custom toggle button that switches between on and off states. Code Example Here’s how you can implement a custom toggle button in SwiftUI: import SwiftUI

struct CustomToggle: View {
    @Binding var isOn: Bool // Binding variable for toggle state

        var body: some View {
            HStack {
                Text("Toggle Setting")
                    .foregroundColor(.primary) // Text color
                Spacer()
                // Custom square toggle design
                RoundedRectangle(cornerRadius: 5) // Rounded corners
                    .fill(isOn ? Color.blue : Color.gray) // Toggle color based on state
                    .frame(width: 60, height: 30) // Toggle size
                    .overlay(
                        Rectangle() // Square knob design
                            .fill(Color.white)
                            .frame(width: 26, height: 26)
                            .offset(x: isOn ? 15 : -15) // Move the square based on state
                            .animation(.easeInOut(duration: 0.2), value: isOn) // Animation for smooth transition
                    )
                    .onTapGesture {
                        isOn.toggle() // Toggle the state on tap
                    }
            }
            .padding() // Padding for the entire toggle
        }
    }

struct ContentView: View {
    @State private var isToggleOn = false // State to manage toggle status

    var body: some View {
        VStack {
            CustomToggle(isOn: $isToggleOn) // Custom toggle instance
            Text(isToggleOn ? "Setting is ON" : "Setting is OFF") // Display current state
                .padding()
        }
        .padding()
    }
}

@main
struct CustomToggleApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView() // Main content view
        }
    
} The full series is available on my profile, and the components can also be found at shipios.app/components. Happy Coding! 🎈 Day 21: Custom Toggle Button, anyone? ⚙️ Day 21: Custom Toggle Button, anyone? ⚙️ Today, we’re going to create a custom toggle button in SwiftUI. custom toggle button Implementing a Custom Toggle Button In this example, we’ll create a visually appealing custom toggle button that switches between on and off states. Code Example Here’s how you can implement a custom toggle button in SwiftUI: import SwiftUI

struct CustomToggle: View {
    @Binding var isOn: Bool // Binding variable for toggle state

        var body: some View {
            HStack {
                Text("Toggle Setting")
                    .foregroundColor(.primary) // Text color
                Spacer()
                // Custom square toggle design
                RoundedRectangle(cornerRadius: 5) // Rounded corners
                    .fill(isOn ? Color.blue : Color.gray) // Toggle color based on state
                    .frame(width: 60, height: 30) // Toggle size
                    .overlay(
                        Rectangle() // Square knob design
                            .fill(Color.white)
                            .frame(width: 26, height: 26)
                            .offset(x: isOn ? 15 : -15) // Move the square based on state
                            .animation(.easeInOut(duration: 0.2), value: isOn) // Animation for smooth transition
                    )
                    .onTapGesture {
                        isOn.toggle() // Toggle the state on tap
                    }
            }
            .padding() // Padding for the entire toggle
        }
    }

struct ContentView: View {
    @State private var isToggleOn = false // State to manage toggle status

    var body: some View {
        VStack {
            CustomToggle(isOn: $isToggleOn) // Custom toggle instance
            Text(isToggleOn ? "Setting is ON" : "Setting is OFF") // Display current state
                .padding()
        }
        .padding()
    }
}

@main
struct CustomToggleApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView() // Main content view
        }
    
} import SwiftUI

struct CustomToggle: View {
    @Binding var isOn: Bool // Binding variable for toggle state

        var body: some View {
            HStack {
                Text("Toggle Setting")
                    .foregroundColor(.primary) // Text color
                Spacer()
                // Custom square toggle design
                RoundedRectangle(cornerRadius: 5) // Rounded corners
                    .fill(isOn ? Color.blue : Color.gray) // Toggle color based on state
                    .frame(width: 60, height: 30) // Toggle size
                    .overlay(
                        Rectangle() // Square knob design
                            .fill(Color.white)
                            .frame(width: 26, height: 26)
                            .offset(x: isOn ? 15 : -15) // Move the square based on state
                            .animation(.easeInOut(duration: 0.2), value: isOn) // Animation for smooth transition
                    )
                    .onTapGesture {
                        isOn.toggle() // Toggle the state on tap
                    }
            }
            .padding() // Padding for the entire toggle
        }
    }

struct ContentView: View {
    @State private var isToggleOn = false // State to manage toggle status

    var body: some View {
        VStack {
            CustomToggle(isOn: $isToggleOn) // Custom toggle instance
            Text(isToggleOn ? "Setting is ON" : "Setting is OFF") // Display current state
                .padding()
        }
        .padding()
    }
}

@main
struct CustomToggleApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView() // Main content view
        }
    
} The full series is available on my profile, and the components can also be found at shipios.app/components . shipios.app/components shipios.app/components Happy Coding! 🎈

How to Create a Custom Toggle Button in iOS 18 - #30DaysOfSwift

Day 11: Embrace the Night 🌙 For the eleventh post of the #30DaysOfSwift series, I am adding a Dark Mode Toggle to switch between Light/Dark modes in SwiftUI. SwiftUI natively supports Dark Mode, and today, we'll create a sleek, minimalistic UI to let users toggle between the two themes. Steps to Add a Dark Mode Toggle: 1. Create a Toggle Button: Add a toggle switch in the settings view that allows users to manually switch between light and dark modes. 2. Customize the Appearance: We'll implement a system that changes the app's color scheme using SwiftUI's @Environment(.colorScheme) modifier. import SwiftUI

struct DarkModeToggleView: View { 

@State private var isDarkMode = false // State to track the mode

var body: some View {
    VStack {
        // Title Text
        Text("Dark Mode Toggle")
            .font(.largeTitle)
            .fontWeight(.bold)
            .padding()

        // Example image to showcase the mode effect
        Image(systemName: isDarkMode ? "moon.fill" : "sun.max.fill")
            .resizable()
            .scaledToFit()
            .frame(width: 100, height: 100)
            .foregroundColor(isDarkMode ? .yellow : .orange) // Custom color for each mode
            .padding()

        // Toggle switch with label
        Toggle(isOn: $isDarkMode) {
            Text(isDarkMode ? "Dark Mode" : "Light Mode")
                .font(.headline)
        }
        .toggleStyle(SwitchToggleStyle(tint: .blue)) // Beautiful blue accent color
        .padding()

    }
    // Apply the color scheme dynamically
    .preferredColorScheme(isDarkMode ? .dark : .light)
    .animation(.easeInOut, value: isDarkMode) // Smooth transition between modes
    .frame(maxWidth: .infinity, maxHeight: .infinity)
    .background(isDarkMode ? Color.black : Color.white) // Set background color based on mode
    .edgesIgnoringSafeArea(.all)
}
}

struct DarkModeToggleView_Previews: PreviewProvider { static var previews: some View { DarkModeToggleView() } } Add this feature to your app, and give your users a sleek way to switch between Light and Dark Mode! 🌗 Happy Coding! P.S. This series is becoming huge! You can read about all the stories by clicking on my profile. Day 11: Embrace the Night 🌙 Day 11: Embrace the Night For the eleventh post of the #30DaysOfSwift series, I am adding a Dark Mode Toggle to switch between Light/Dark modes in SwiftUI. SwiftUI natively supports Dark Mode, and today, we'll create a sleek, minimalistic UI to let users toggle between the two themes. Steps to Add a Dark Mode Toggle: 1. Create a Toggle Button: 1. Create a Toggle Button: Add a toggle switch in the settings view that allows users to manually switch between light and dark modes. 2. Customize the Appearance: 2. Customize the Appearance: We'll implement a system that changes the app's color scheme using SwiftUI's @Environment(.colorScheme) modifier. @Environment(.colorScheme) import SwiftUI

struct DarkModeToggleView: View { 

@State private var isDarkMode = false // State to track the mode

var body: some View {
    VStack {
        // Title Text
        Text("Dark Mode Toggle")
            .font(.largeTitle)
            .fontWeight(.bold)
            .padding()

        // Example image to showcase the mode effect
        Image(systemName: isDarkMode ? "moon.fill" : "sun.max.fill")
            .resizable()
            .scaledToFit()
            .frame(width: 100, height: 100)
            .foregroundColor(isDarkMode ? .yellow : .orange) // Custom color for each mode
            .padding()

        // Toggle switch with label
        Toggle(isOn: $isDarkMode) {
            Text(isDarkMode ? "Dark Mode" : "Light Mode")
                .font(.headline)
        }
        .toggleStyle(SwitchToggleStyle(tint: .blue)) // Beautiful blue accent color
        .padding()

    }
    // Apply the color scheme dynamically
    .preferredColorScheme(isDarkMode ? .dark : .light)
    .animation(.easeInOut, value: isDarkMode) // Smooth transition between modes
    .frame(maxWidth: .infinity, maxHeight: .infinity)
    .background(isDarkMode ? Color.black : Color.white) // Set background color based on mode
    .edgesIgnoringSafeArea(.all)
}
}

struct DarkModeToggleView_Previews: PreviewProvider { static var previews: some View { DarkModeToggleView() } } import SwiftUI

struct DarkModeToggleView: View { 

@State private var isDarkMode = false // State to track the mode

var body: some View {
    VStack {
        // Title Text
        Text("Dark Mode Toggle")
            .font(.largeTitle)
            .fontWeight(.bold)
            .padding()

        // Example image to showcase the mode effect
        Image(systemName: isDarkMode ? "moon.fill" : "sun.max.fill")
            .resizable()
            .scaledToFit()
            .frame(width: 100, height: 100)
            .foregroundColor(isDarkMode ? .yellow : .orange) // Custom color for each mode
            .padding()

        // Toggle switch with label
        Toggle(isOn: $isDarkMode) {
            Text(isDarkMode ? "Dark Mode" : "Light Mode")
                .font(.headline)
        }
        .toggleStyle(SwitchToggleStyle(tint: .blue)) // Beautiful blue accent color
        .padding()

    }
    // Apply the color scheme dynamically
    .preferredColorScheme(isDarkMode ? .dark : .light)
    .animation(.easeInOut, value: isDarkMode) // Smooth transition between modes
    .frame(maxWidth: .infinity, maxHeight: .infinity)
    .background(isDarkMode ? Color.black : Color.white) // Set background color based on mode
    .edgesIgnoringSafeArea(.all)
}
}

struct DarkModeToggleView_Previews: PreviewProvider { static var previews: some View { DarkModeToggleView() } } Add this feature to your app, and give your users a sleek way to switch between Light and Dark Mode! 🌗 Happy Coding! Happy Coding! P.S. This series is becoming huge! You can read about all the stories by clicking on my profile.

How to Add a Dark Mode Toggle for iOS 18 - #30DaysOfSwift

Creating engaging and user-friendly interfaces is crucial in web and app development. Toggle switches, though simple, play a significant role in enhancing user experience by providing an intuitive way to control settings. However, finding the perfect toggle design that is both functional and aesthetically pleasing can be a challenge for developers. This article addresses the problem by showcasing 12 creative examples with code. For developers, this collection offers valuable inspiration and practical implementation tips. These creative toggle designs help enhance the overall user experience and make your projects more visually appealing. All snippets are interactive, so feel free to try them out on the go. Hopefully, these will be useful for you! Let's dive in! 1. Skillet Switch By: Jon Kantner https://codepen.io/jkantner/pen/rNqxNXW?embedable=true 2. Squishy Switch By: Nicolas Jesenberger https://codepen.io/nicolasjesenberger/pen/bGQwBYo?embedable=true 3. Colorful Theme Switch By: Jon Kantner https://codepen.io/jkantner/pen/eYPYppR?embedable=true 4. Toothed Toggle By: Josetxu https://codepen.io/josetxu/pen/NWEPmGz?embedable=true 5. Merging Letter Toggle By: Jon Kantner https://codepen.io/jkantner/pen/gOZrOQm?embedable=true 6. Gooey Toggle Switch By: Nicolas Jesenberger https://codepen.io/nicolasjesenberger/pen/xxmbvxL?embedable=true 7. Neon Toggle Switch By: Jon Kantner https://codepen.io/jkantner/pen/MWzqMrp?embedable=true 8. Night && Day Toggle By: Jhey https://codepen.io/jh3y/pen/LYgjpYZ?embedable=true 9. Light/Dark Toggle By: Jon Kantner https://codepen.io/jkantner/pen/eYygqJm?embedable=true 10. Day and Night Toggle By: Aysenur Turk https://codepen.io/TurkAysenur/pen/bGawdKv?embedable=true 11. City Life Toggle By: Josetxu https://codepen.io/josetxu/pen/poKbEjG?embedable=true 12. Sci-Fi Door Lock Toggle By: Chris Gannon https://codepen.io/chrisgannon/pen/bLeMEB?embedable=true Writing has always been my passion and it gives me pleasure to help and inspire people. If you have any questions, feel free to reach out! Make sure to receive the best resources, tools, productivity tips, and career growth tips I discover by subscribing to my newsletter! Also, connect with me on Twitter, LinkedIn, and GitHub! Creating engaging and user-friendly interfaces is crucial in web and app development. Toggle switches, though simple, play a significant role in enhancing user experience by providing an intuitive way to control settings. However, finding the perfect toggle design that is both functional and aesthetically pleasing can be a challenge for developers. This article addresses the problem by showcasing 12 creative examples with code. For developers, this collection offers valuable inspiration and practical implementation tips. These creative toggle designs help enhance the overall user experience and make your projects more visually appealing. All snippets are interactive, so feel free to try them out on the go. Hopefully, these will be useful for you! Let's dive in! 1. Skillet Switch Skillet Switch By: Jon Kantner Jon Kantner https://codepen.io/jkantner/pen/rNqxNXW?embedable=true https://codepen.io/jkantner/pen/rNqxNXW?embedable=true 2. Squishy Switch Squishy Switch By: Nicolas Jesenberger Nicolas Jesenberger https://codepen.io/nicolasjesenberger/pen/bGQwBYo?embedable=true https://codepen.io/nicolasjesenberger/pen/bGQwBYo?embedable=true 3. Colorful Theme Switch Colorful Theme Switch By: Jon Kantner Jon Kantner https://codepen.io/jkantner/pen/eYPYppR?embedable=true https://codepen.io/jkantner/pen/eYPYppR?embedable=true 4. Toothed Toggle Toothed Toggle By: Josetxu Josetxu https://codepen.io/josetxu/pen/NWEPmGz?embedable=true https://codepen.io/josetxu/pen/NWEPmGz?embedable=true 5. Merging Letter Toggle Merging Letter Toggle By: Jon Kantner Jon Kantner https://codepen.io/jkantner/pen/gOZrOQm?embedable=true https://codepen.io/jkantner/pen/gOZrOQm?embedable=true 6. Gooey Toggle Switch Gooey Toggle Switch By: Nicolas Jesenberger Nicolas Jesenberger https://codepen.io/nicolasjesenberger/pen/xxmbvxL?embedable=true https://codepen.io/nicolasjesenberger/pen/xxmbvxL?embedable=true 7. Neon Toggle Switch Neon Toggle Switch By: Jon Kantner Jon Kantner https://codepen.io/jkantner/pen/MWzqMrp?embedable=true https://codepen.io/jkantner/pen/MWzqMrp?embedable=true 8. Night && Day Toggle Night && Day Toggle By: Jhey Jhey https://codepen.io/jh3y/pen/LYgjpYZ?embedable=true https://codepen.io/jh3y/pen/LYgjpYZ?embedable=true 9. Light/Dark Toggle Light/Dark Toggle By: Jon Kantner Jon Kantner https://codepen.io/jkantner/pen/eYygqJm?embedable=true https://codepen.io/jkantner/pen/eYygqJm?embedable=true 10. Day and Night Toggle Day and Night Toggle By: Aysenur Turk Aysenur Turk https://codepen.io/TurkAysenur/pen/bGawdKv?embedable=true https://codepen.io/TurkAysenur/pen/bGawdKv?embedable=true 11. City Life Toggle City Life Toggle By: Josetxu Josetxu https://codepen.io/josetxu/pen/poKbEjG?embedable=true https://codepen.io/josetxu/pen/poKbEjG?embedable=true 12. Sci-Fi Door Lock Toggle Sci-Fi Door Lock Toggle By: Chris Gannon Chris Gannon https://codepen.io/chrisgannon/pen/bLeMEB?embedable=true https://codepen.io/chrisgannon/pen/bLeMEB?embedable=true Writing has always been my passion and it gives me pleasure to help and inspire people. If you have any questions, feel free to reach out! Make sure to receive the best resources, tools, productivity tips, and career growth tips I discover by subscribing to my newsletter ! my newsletter Also, connect with me on Twitter , LinkedIn , and GitHub ! Twitter LinkedIn GitHub

12 Awesome Toggle Switch Designs (With Source Code!) 🎨💖

Attributes offer the ability to add structured, machine-readable metadata information on declarations in code: Classes, methods, functions, parameters, properties, and class constants can be the target of an attribute. I believe the definition is on point, and I'm confident most developers reading this article have encountered attributes at least once. If you haven't, they are essentially metadata added to a class. At this point, you might be wondering how they differ from PHPDOCs then? Well, they are first-class citizens; they are actual PHP classes, and yes I know, it changes the whole game now; you don't have to write regular expressions to extract things from the PHPDocs, and you can even maintain some form of state within the properties. Since I am a bit late to the party, classic examples of attributes abound. So, why not build something cool with them instead? Making Routes Toggleable When working with a team, I often receive messages from other developers (frontend guys, I am looking at you), notifying me that a route isn't working as expected. At times, I wish I could easily disable the route for a specific environment, like the staging environment, while maintaining its functionality locally. This way, my fellow backend developers and I can work on it, push code, and maintain our typical workflow without concerns about accidental usage. Occasionally, it's simply a new route that needs to stay exclusive to the testing environment. So, pondering this, I thought it would be cool to mark an action as disabled or ignored. And guess what? With attributes, this turned out to be super easy and clean. Let's start by creating an attribute. I will name mine Ignore, and it will have a single property called in <?php

namespace App\Attributes;

use Attribute;

#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_METHOD)]
class Ignore
{
    public function __construct(
        public array $in = ['production']
    ) {
    }
} That's it, you just created an attribute, you will also notice that we've limited its scope to classes and methods, allowing this attribute to be placed exclusively on those two entities. Now, we can use it like so namespace App\Http\Controllers;

use App\Attributes\Ignore;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Symfony\Component\HttpFoundation\Response

class TwoFactorQrCodeController extends Controller
{
    #[Ignore(in: ['production', 'staging'])]
    public function show(Request $request): Response
    {
        if (is_null($request->user()->two_factor_secret)) {
            return [];
        }

        return response()->json([
            'svg' => $request->user()->twoFactorQrCodeSvg(),
            'url' => $request->user()->twoFactorQrCodeUrl(),
        ]);
    }
} You can see that this already reads well,;ignore it in production and staging. Still, we need to make this functional, and there are a few methods to achieve this. The simplest is using a middleware. Let's create a middleware, I will name it IsRouteIgnored, feel free to choose any name you prefer php artisan make:middleware IsRouteIgnored Now we can implement the logic; the idea is simple: we intercept the requests of the routes that use this middleware, and we then check if the action has the Ignore attribute, if it does, we check whether the current environment is permitted to have this route or not. For this, we will use the magic of the Reflection API, let's dive into the code. <?php

namespace App\Http\Middleware;

use Closure;
use ReflectionMethod;
use App\Attributes\Ignore;
use Illuminate\Http\Request;
use Illuminate\Routing\Route;
use Symfony\Component\HttpFoundation\Response;

class IsRouteIgnored
{
    public function handle(Request $request, Closure $next): Response
    {
        $route = $request->route();

        if (!($route instanceof Route) || $route->action['uses'] instanceof Closure) {
            return $next($request);
        }

        $reflection = new ReflectionMethod($route->getControllerClass(), $route->getActionMethod());

        $attributes = $reflection->getAttributes(Ignore::class);

        if (!empty($attributes) && in_array(config('app.env'), $attributes[0]->newInstance()->in)) {
            abort(404);
        }

        return $next($request);
    }
} We're creating a reflection of the method the route leads to so we retrieve the Ignore attribute. By default, attributes are not repeatable, meaning they can only be used once per entity. Since we've specified our interest solely in the Ignore attribute, we will end up with a single-element array. We can now instantiate the attribute by calling newInstance(), returning to the realm of regular classes. We then check the environments in which this route should be ignored within the in property. In this case, the route will return a 404 response for the production and staging environments but will function in the local and testing environments. Afterward, you can register the middleware globally or within the API routes, as you would normally do, and you can start ignoring routes by marking them with the attribute. Conclusion With just a few lines of code, we've enabled toggleable routes. While the implementation was relatively basic, the example was meant to showcase the power of attributes. I mean, come on, how cool is that? Toggling routes on and off within specific environments of your choice, you can even adjust the Ignore attribute to exclude the route from all environments except for the ones you specify, and the options are endless. Next time you ponder marking a class as something specific, consider giving Attributes a shot! 🪄 Attributes offer the ability to add structured, machine-readable metadata information on declarations in code: Classes, methods, functions, parameters, properties, and class constants can be the target of an attribute. Attributes offer the ability to add structured, machine-readable metadata information on declarations in code: Classes, methods, functions, parameters, properties, and class constants can be the target of an attribute. I believe the definition is on point, and I'm confident most developers reading this article have encountered attributes at least once. If you haven't, they are essentially metadata added to a class. At this point, you might be wondering how they differ from PHPDOCs then? Well, they are first-class citizens; they are actual PHP classes , and yes I know, it changes the whole game now; you don't have to write regular expressions to extract things from the PHPDocs, and you can even maintain some form of state within the properties. PHPDOCs actual PHP classes regular expressions Since I am a bit late to the party, classic examples of attributes abound. So, why not build something cool with them instead? Making Routes Toggleable When working with a team, I often receive messages from other developers (frontend guys, I am looking at you), notifying me that a route isn't working as expected. At times, I wish I could easily disable the route for a specific environment, like the staging environment, while maintaining its functionality locally. This way, my fellow backend developers and I can work on it, push code, and maintain our typical workflow without concerns about accidental usage. Occasionally, it's simply a new route that needs to stay exclusive to the testing environment. So, pondering this, I thought it would be cool to mark an action as disabled or ignored. And guess what? With attributes, this turned out to be super easy and clean. Let's start by creating an attribute. I will name mine Ignore , and it will have a single property called in Ignore in <?php

namespace App\Attributes;

use Attribute;

#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_METHOD)]
class Ignore
{
    public function __construct(
        public array $in = ['production']
    ) {
    }
} <?php

namespace App\Attributes;

use Attribute;

#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_METHOD)]
class Ignore
{
    public function __construct(
        public array $in = ['production']
    ) {
    }
} That's it, you just created an attribute, you will also notice that we've limited its scope to classes and methods, allowing this attribute to be placed exclusively on those two entities. Now, we can use it like so namespace App\Http\Controllers;

use App\Attributes\Ignore;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Symfony\Component\HttpFoundation\Response

class TwoFactorQrCodeController extends Controller
{
    #[Ignore(in: ['production', 'staging'])]
    public function show(Request $request): Response
    {
        if (is_null($request->user()->two_factor_secret)) {
            return [];
        }

        return response()->json([
            'svg' => $request->user()->twoFactorQrCodeSvg(),
            'url' => $request->user()->twoFactorQrCodeUrl(),
        ]);
    }
} namespace App\Http\Controllers;

use App\Attributes\Ignore;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Symfony\Component\HttpFoundation\Response

class TwoFactorQrCodeController extends Controller
{
    #[Ignore(in: ['production', 'staging'])]
    public function show(Request $request): Response
    {
        if (is_null($request->user()->two_factor_secret)) {
            return [];
        }

        return response()->json([
            'svg' => $request->user()->twoFactorQrCodeSvg(),
            'url' => $request->user()->twoFactorQrCodeUrl(),
        ]);
    }
} You can see that this already reads well,; ignore it in production and staging . Still, we need to make this functional, and there are a few methods to achieve this. The simplest is using a middleware. ignore it in production and staging Let's create a middleware, I will name it IsRouteIgnored , feel free to choose any name you prefer IsRouteIgnored php artisan make:middleware IsRouteIgnored php artisan make:middleware IsRouteIgnored Now we can implement the logic; the idea is simple: we intercept the requests of the routes that use this middleware, and we then check if the action has the Ignore attribute, if it does, we check whether the current environment is permitted to have this route or not. Ignore For this, we will use the magic of the Reflection API , let's dive into the code. Reflection API <?php

namespace App\Http\Middleware;

use Closure;
use ReflectionMethod;
use App\Attributes\Ignore;
use Illuminate\Http\Request;
use Illuminate\Routing\Route;
use Symfony\Component\HttpFoundation\Response;

class IsRouteIgnored
{
    public function handle(Request $request, Closure $next): Response
    {
        $route = $request->route();

        if (!($route instanceof Route) || $route->action['uses'] instanceof Closure) {
            return $next($request);
        }

        $reflection = new ReflectionMethod($route->getControllerClass(), $route->getActionMethod());

        $attributes = $reflection->getAttributes(Ignore::class);

        if (!empty($attributes) && in_array(config('app.env'), $attributes[0]->newInstance()->in)) {
            abort(404);
        }

        return $next($request);
    }
} <?php

namespace App\Http\Middleware;

use Closure;
use ReflectionMethod;
use App\Attributes\Ignore;
use Illuminate\Http\Request;
use Illuminate\Routing\Route;
use Symfony\Component\HttpFoundation\Response;

class IsRouteIgnored
{
    public function handle(Request $request, Closure $next): Response
    {
        $route = $request->route();

        if (!($route instanceof Route) || $route->action['uses'] instanceof Closure) {
            return $next($request);
        }

        $reflection = new ReflectionMethod($route->getControllerClass(), $route->getActionMethod());

        $attributes = $reflection->getAttributes(Ignore::class);

        if (!empty($attributes) && in_array(config('app.env'), $attributes[0]->newInstance()->in)) {
            abort(404);
        }

        return $next($request);
    }
} We're creating a reflection of the method the route leads to so we retrieve the Ignore attribute. By default, attributes are not repeatable, meaning they can only be used once per entity. Since we've specified our interest solely in the Ignore attribute, we will end up with a single-element array. We can now instantiate the attribute by calling newInstance() , returning to the realm of regular classes. We then check the environments in which this route should be ignored within the in property. In this case, the route will return a 404 response for the production and staging environments but will function in the local and testing environments. Ignore Ignore newInstance() in 404 Afterward, you can register the middleware globally or within the API routes, as you would normally do, and you can start ignoring routes by marking them with the attribute. Conclusion With just a few lines of code, we've enabled toggleable routes. While the implementation was relatively basic, the example was meant to showcase the power of attributes. I mean, come on, how cool is that? Toggling routes on and off within specific environments of your choice, you can even adjust the Ignore attribute to exclude the route from all environments except for the ones you specify, and the options are endless. Ignore Next time you ponder marking a class as something specific, consider giving Attributes a shot! 🪄 Next time you ponder marking a class as something specific, consider giving Attributes a shot! 🪄

PHP Development: Creating Toggleable Laravel Routes with Attributes

Often, developers create technical solutions using whatever is available to get the functionality up and running. Especially when it is necessary to test some product hypothesis and it doesn't make much sence to spend a lot of time and resources on it. After the hypothesis is confirmed, an even more interesting time begins - the search for tradeoffs: you need to release features quickly, adapting to the users number growth. It is very handy to be able to change the behavior of the service at any time without restarting the servers, or to turn off a broken functionality or to conduct AB-testing. To do this, developers usually use . If your startup has not a giant, but a small group of enthusiasts - you will have to solve this problem using available tools. In this article, I will show you a simple way of how to implement Feature Toggle using a shared SQL database. Feature Toggles Description of a typical system No matter how much effort is put into the development of fault-tolerant self-sustainable systems, manual interventions are inevitable: fixing data inconsistencies, triggering tasks, recovering data after an outage, backfilling or migrations, displaying business operations and related data. If a problem could be fixed easily, a developer can adjust data directly in the database, or write a bash/python/whatever script. We usually avoid direct accessing the data, but circumstances could make you do it. But there is a more reliable way - an application with internal use - Administration Panel. Benefits of having Admin Panel: authorized access; logging and auditing all the actions done by a user; its code usually reviewed and tested; accessible not only by users, but by tech support. Often admin panel is designed to access database of business-logic servers. This approach has some disadvantages, but is a good tradeoff: providing an acceptable level of security through simple implementation. Thus, most probably, you can use the main database to store the settings, including the feature-toggle and access them from your servers. Get your hands dirty with code Simple toggle The simplest use case is a two position toggle - either enable for all or disable for all. private final FeatureToggleService featureToggleService;

public void businessLogic() {
   if (featureToggleService.isFeatureEnabled(IMPORTANT_FEATURE)) {
       doImportantFeatureStuff();
   } else {
       log.info("Feature disabled {}", IMPORTANT_FEATURE);
   }
} If I implemented it in memory, I'd check if there is a key in a hash set. If there is one - feature is enabled, otherwise - disabled. In an SQL database there could be a table, which contains the names of the features - that's all what we need here. We can query the keys and that's how it could look like: public class FeatureToggleService {

   private static final String STATE_QUERY = "SELECT id FROM features WHERE name = (?)";

   private final JdbcOperations jdbcOperations;

   private final LoadingCache<String, Boolean> toggleStateCache = CacheBuilder.newBuilder()
           .expireAfterWrite(60, TimeUnit.SECONDS)
           .build(new CacheLoader<>() {
               public Boolean load(String featureName) {
                   return jdbcOperations.queryForList(STATE_QUERY, String.class, featureName)
                              .size() > 0;
               }
           });

   public boolean isFeatureEnabled(String featureName) {
       boolean state = toggleStateCache.getUnchecked(featureName);
       return Boolean.TRUE.equals(state);
   }
} In the example above, I used a cache from Google Guava. It’s a simple local cache, but in 99% of cases it will probably meet your requirements. Feature are toggled infrequently, there is no point in making requests often. I chose 60 seconds as an example - but it’s a good trade off, not too many requests and not too long switching. User specific toggle A slightly more complicated case. You want to test functionality in production, but you don't want it to be available to all users. Instead, you want to enable the feature only for a set of users, who are considered to be testers. private final FeatureToggleService featureToggleService;

public void businessLogic(LoggedUser loggedUser) {
   if (featureToggleService.isFeatureEnabled(IMPORTANT_FEATURE, loggedUser.id())) {
       doImportantFeatureStuff();
   } else {
       log.info("Feature disabled {}", IMPORTANT_FEATURE);
   }
} The third state of the feature has appeared - testing. So states are: Enabled for all Disabled for all Enabled for testers If feature is enabled for testing - you should check if current user is a tester. In other words whether user is in a list of persons who should have access to the feature. The database will require a second column that will store the state of the feature (it could be a number or a meaningful name). And you will also need to store a list of testers somewhere, for example, it could be another table in the database. And the implementation could be: public class FeatureToggleService {

   private static final String STATE_QUERY =
            "SELECT enabled_for FROM features WHERE name = (?)";
   private static final String TESTERS_QUERY = "SELECT id FROM test_users";
   private final JdbcOperations jdbcOperations;

   private final Supplier<Set<Long>> testUsersSupplier =
           memoizeWithExpiration(this::extractTesters, 60, TimeUnit.SECONDS);

   private final LoadingCache<String, String> toggleStateCache = CacheBuilder.newBuilder()
           .expireAfterWrite(60, TimeUnit.SECONDS)
           .build(new CacheLoader<>() {
               public String load(String featureName) {
                   return jdbcOperations.queryForList(STATE_QUERY, String.class, featureName)
                           .stream().findFirst().orElse("NONE");
               }
           });

   public boolean isFeatureEnabled(String featureName, long userId) {
       String state = toggleStateCache.getUnchecked(featureName);
       return "ALL".equals(state) ||
               ("TEST".equals(state) && testUsersSupplier.get().contains(userId));
   }

   private Set<Long> extractTesters() {
       return Set.copyOf(jdbcOperations.queryForList(TESTERS_QUERY, Long.class));
   }
} First we fetch state of the feature by it’s name (either from database or cache), then if it’s consider it enabled for all, or if it’s - consider it only enabled for testers. If so we fetch list of testers (either from database or from cache) and check if current user is in the list. If none of above - consider feature disabled for all. ALL TEST What could go wrong with the implementations above There is one un-obvious problem with local cache which you should be aware of: you’re setting feature enabled for all 09:45:27 request 1 has come to server 1 and feature worked as enabled 09:45:47 request 2 has come to server 2 and feature didn’t work as disabled 09:45:51 Why is that so? Local caches don’t know anything about other ot servers, in most cases it could not be a problem at all. Otherwise, you should do one of following: continue using local cache but evict it by a notification (using a pub sub system or broadcast messages); use a distributed cache (eCache or similar) and evict it on each change; use an in-memory databases (Redis, Zookeeper or similar) to store features and provide low-cost access to it; use a paid service which provides this functionality (there are a number of them, no adds and preferences here); come up with your own brilliant idea, there could be a plenty of them :) Conclusion Many developers think that it’s cool to use a fancy framework, but you need to assess if it's really justified. It's often easier to write a simple module that satisfies specific needs of your application, develop it your own way. But here you need to feel the boundary - writing your own HashMap from scratch does not make any sense.

Use Feature Toggle to Safely Release Updates On Your Server

Nowadays, the ability to switch between a light or a dark theme has become extremely popular on the internet. It has been a while since we began to see it on desktop applications, but now, we can also see it every day on most websites we use: Github, Stackoverflow, , etc. There are multiple ways to implement it, I’ll show you mine. Twitter Writing the themes It’s 2022, we survived the Coronavirus, and Internet Explorer is finally dead. I think it’s a good time to if you haven’t already (you can read if you are not familiar with them or if you don’t know what I’m talking about). start using CSS custom properties this fantastic post from Chris Coyier Even though I’ve started talking about two themes, I’m obviously talking about having . The key to creating those variants is to write every single color that appears on your theme in a custom property. In my case, I’ve started defining all the colors used in the light theme, which is the default I’ve chosen for the situation when we don’t know the user preference: a single CSS code with two variants body {
  --bg-color: #fff;
  --bg-color-secondary: #eee;
  --text-color: #303030;
  --text-color-secondary: #707070;
  --border-color: #eeeeee;
} Once we have the values for the light variant, we need to define the same properties for the dark one, and we will add them inside a media query. @media (prefers-color-scheme: dark) {
  body {
    --bg-color: #292639;
    --bg-color-secondary: #1b1928;
    --text-color: #ebeaf7;
    --text-color-secondary: #bebbd2;
    --border-color: #3a3650;
  }
} Now, we can just use those properties in our CSS. body {
  background: var(--bg-color);
  color: var(--text-color);
  /* ... */ 
}

.header {
  border-bottom: 1px solid var(--border-color);
  /* ... */ 
}

.menu-item {
  color: var(--text-color-secondary);
  /* ... */ 
}

.button {
  background: var(--bg-color-secondary);
  border: 1px solid var(--border-color);
  /* ... */ 
}

/* ... */ Some UX considerations Don’t get me wrong; I’m not a UX designer. Anyway, I feel comfortable enough to give you some tips regarding UX on light/dark themes: . There are lots of dark colors apart from the , in fact, you can see that I’m not using black as a background color on this site. Light is not necessarily white either. There are a lot of places to get inspiration from; if you are not an expert in color theory either, review what other sites do or take some ideas from IDE themes. Dark is not black #000000 . I could be wrong, but shadows are always dark. Take into consideration where the colors are being used. You can use a different kind of shadow for each variant, maybe you will need them to be more intense (or with less transparency) in the dark theme, but they should be dark. There is no need to switch every color . Ensure that you don’t hardcode color codes in the or the properties of your SVG icons. Use in those properties and let the CSS cascade do its job. Base the color of the SVG icons on the content stroke fill currentColor . Not every single picture will play well with both themes. Test the images you choose for your content and select those that look fine with dark and light backgrounds. Sometimes that could be impossible, don’t worry, there are different ways to show multiple images to your users, for example: Keep an eye on content images <picture>
  <source srcset="image-dark.png" media="(prefers-color-scheme: dark)" />
  <source srcset="image-light.png" media="(prefers-color-scheme: light)" />
  <img src="image-light.png" />
</picture> Another option, which is the one I’ve chosen, is to apply a filter to the pictures in the dark mode, making them darker and with a higher contrast: @media (prefers-color-scheme: dark) {
  img {
    filter: brightness(0.9) contrast(1.1);
  }
} If you follow these steps, you will now have two versions of your theme. I know it is not always as simple as I described here, particularly if you are not creating your theme from scratch but adding a new variant to the existing one. , and don’t give up. Adapt these tips to your situation Letting the user switch At this point, we have assumed the user will always want to see your website with the color mode preference that we read in the media feature. That’s a big assumption. In my opinion, it’s a good starting point, but . prefers-color-scheme we will always let the user switch from light to dark or vice-versa The most common way to do it is to create a fancy switch, but any kind of button will do the job also. This article aims to show you how you can implement the functionality, and we won’t focus on the design of the switch. Anyway, you can for inspiration or take a look at the code of my own switch on this Codepen: search here https://codepen.io/artberri/pen/abYzjQR?embedable=true Once we have designed our switch or button, what we should do is implement the functionality with javascript. We will be able to do it with this simple code: // Get the button element
const btn = document.querySelector(".your-button-or-switch-class");
// Detect if user preference is dark
const prefersDarkScheme = window.matchMedia("(prefers-color-scheme: dark)");
// On button click
btn.addEventListener("click", function() {
  // Get users preference
  const userSystemPreference = prefersDarkScheme.matches ? "dark" : "light";
  // Choose the class that will be added or removed
  const toggleClass = userSystemPreference === "dark" ? "light" : "dark";
  // Add or remove the class on the <html> element
  document.documentElement.classList.toggle(toggleClass);
}); As you can see, we will add or remove the class to the element if the user prefers the light theme, and we will toggle the class in case their preferred option is dark. This won’t trigger any effect for now, but it will with this simple addition to our CSS: dark html light .dark body {
  --bg-color: #292639;
  --bg-color-secondary: #1b1928;
  --text-color: #ebeaf7;
  --text-color-secondary: #bebbd2;
  --border-color: #3a3650;
}

@media (prefers-color-scheme: dark) {
  .light body {
    --bg-color: #fff;
    --bg-color-secondary: #eee;
    --text-color: #303030;
    --text-color-secondary: #707070;
    --border-color: #eeeeee;
  }
} With all this, our website will be loaded with the preferred theme of the user, and it will allow them to switch if they want. So, are we done here? Not yet. Storing user’s preference There is only one thing we lack; . I think the easiest way is to save it in the browser’s local storage and to do so, we need to modify the Javascript code I’d shown you previously. we need to store the user’s preferences to keep them between sessions or page navigation const btn = document.querySelector(".your-button-or-switch-class");
const prefersDarkScheme = window.matchMedia("(prefers-color-scheme: dark)");
btn.addEventListener("click", function() {
  const userSystemPreference = prefersDarkScheme.matches ? "dark" : "light";
  const toggleClass = userSystemPreference === "dark" ? "light" : "dark";
  document.documentElement.classList.toggle(toggleClass);

  // Obtain which is the user's current preference for our website
  const userCurrentPreference = document.documentElement.classList.contains(toggleClass)
    ? toggleClass
    : userSystemPreference;
  // Save it in local storage
  localStorage.setItem("mode", mode);
}); This little modification will get the current mode based on the class of the document (or its absence) and save it on local storage. Once the setting is saved, we need to ensure that we use it on every page load, and we will do that by executing this code in the of our webpage before loading any CSS: html <head> <script type="text/javascript">
  (function () {
      var userCurrentPreference = localStorage.getItem("mode");
      if (userCurrentPreference === "dark") document.documentElement.classList.toggle("dark");
      else if (userCurrentPreference === "light") document.documentElement.classList.toggle("light");
  })();
</script> Wondering why I’m asking you to add some synchronous Javascript code directly in the of your HTML? By adding this snippet asynchronously, or after the HTML and the CSS is loaded, you will run the risk of having a flash of incorrect theme color (this means that the wrong theme could be shown during some milliseconds). The overload of this code is worth in my opinion. Some people use a cookie-based solution to avoid this code, but it needs to be implemented server-side, which is not a possibility if you have a static-generated site like me. head I hope you enjoy reading; don’t forget to share it on your preferred social network if you do so. Also published here.

Adding Light and Dark Modes, with a Toggle Switch, to Your Website

When I rebuilt my , I knew I wanted to have some fun with the design, and a dark and light mode fit the bill. I enjoyed a lot of the discoveries I made during this project, but my favorite has to be the color-changing SVGs. This tutorial assumes familiarity with React, and I am using v17.0.1 and functional components. portfolio site First, I created a base layout. Next, I put together my and color schemes. It took a little trial and error, but after testing all my combinations for and experimenting with placement, I found I needed 6 CSS variables. I guess you could say I used “dark first” development because the variable names make sense in the context of the dark theme. The light theme has less variation but needed where would be the same color as the background. dark light sufficient contrast --button-border --accent .theme-dark {
  --dark-text: #292929;
  --light-text: #F9F8F8;  
  --dark-background: #2F4550;
  --light-background: #586F7C;
  --accent: #B8DBD9;
  --button-border: #B8DBD9;
} .theme-light {
  --dark-text: #5E4B56;
  --light-text: #5E4B56;
  --dark-background: #DBE7E4;
  --light-background: #EDDCD2;
  --accent: #DBE7E4;
  --button-border: #5E4B56;
} Then, I set about applying colors to my base layout: html, #root {
  background-color: var(--dark-background);
  color: var(--dark-text);
}

nav {
  background-color: var(--dark-background);
  color: var(--light-text);
}

.main-container {
  background-color: var(--light-background);
} I also set the backgrounds of the sections of content that I wanted to pop to . would have worked on all backgrounds in the dark theme, but I set the section titles to to make them stand out more. --accent --dark-text --light-text I found Musthaq Ahamad‘s , and set about applying it to functional React components.I put functions for changing the theme and checking localStorage for theme preferences into a file called . basic theme switcher tutorial themes.js function setTheme(themeName) {
    localStorage.setItem('theme', themeName);
    document.documentElement.className = themeName;
}

function keepTheme() {
  if (localStorage.getItem('theme')) {
    if (localStorage.getItem('theme') === 'theme-dark') {
      setTheme('theme-dark');
    } else if (localStorage.getItem('theme') === 'theme-light') {
      setTheme('theme-light')
    }
  } else {
    setTheme('theme-dark')
  }
}

module.exports = {
  setTheme,
  keepTheme
} In my file, I added to my . App.js keepTheme() useEffect() import { keepTheme } from './utils/themes';

function App() {
  useEffect(() => {
      keepTheme();
  })
} Next, I added the toggle component to my navigation bar component. I styled the toggle following based on . Then I . While this toggle is so cute that you could die, this tutorial will work with any or clickable . First, I set up the basic JSX, the local state, and a variable to hold the theme we get from localStorage: Chris Bongers’ Tutorial Katia De Juan’s Dribbble adjusted the size and flipped it to default to dark mode <button> <input> import React, { useEffect, useState } from 'react';
import '../styles/toggle.css';
import { setTheme } from '../utils/themes';

function Toggle() {
  const [togClass, setTogClass] = useState('dark');
  let theme = localStorage.getItem('theme');
  return (
        <div className="container--toggle">
           <input type="checkbox" id="toggle" className="toggle--checkbox" onClick={handleOnClick} />
            <label htmlFor="toggle" className="toggle--label">
                <span className="toggle--label-background"></span>
            </label>
        </div>
    )
}

export default Toggle; When a user clicks the toggle, I want the theme on the page to change and the toggle to change with it. I added the imported function and from the local state to a handleOnClick function. You can see where it is passed to the clickable part of the toggle in the JSX above. setTheme() setTogClass() const handleOnClick = () => {
  if (localStorage.getItem('theme') === 'theme-dark') {
      setTheme('theme-light');
      setTogClass('light')
  } else {
      setTheme('theme-dark');
      setTogClass('dark')
  }
} I used this component’s to make sure the local state togClass always loads with the correct theme. useEffect() useEffect(() => {
    if (localStorage.getItem('theme') === 'theme-dark') {
        setTogClass('dark')
    } else if (localStorage.getItem('theme') === 'theme-light') {
        setTogClass('light')
    }
}, [theme]) Because my toggle is a checkbox, the dark theme should show the unchecked (moon) state and the light theme should show the checked (sun) state. I couldn’t get to work how I wanted, so I replaced the unchecked with this conditional rendering (conditional operator): defaultChecked <input> ternary operator {
    togClass === "light" ?
    <input type="checkbox" id="toggle" className="toggle--checkbox" onClick={handleOnClick} checked />
    :
    <input type="checkbox" id="toggle" className="toggle--checkbox" onClick={handleOnClick} />
} If you used a , you could easily use conditional rendering like this to change the className attribute within the tag and get the same effect. <button> <button> Put all together, the code for the toggle component looks like this: import React, { useEffect, useState } from 'react';
import '../styles/toggle.css';
import { setTheme } from '../utils/themes';

function Toggle() {
    const [togClass, setTogClass] = useState('dark');
    let theme = localStorage.getItem('theme');

    const handleOnClick = () => {
        if (localStorage.getItem('theme') === 'theme-dark') {
            setTheme('theme-light');
            setTogClass('light')
        } else {
            setTheme('theme-dark');
            setTogClass('dark')
        }
    }

    useEffect(() => {
        if (localStorage.getItem('theme') === 'theme-dark') {
            setTogClass('dark')
        } else if (localStorage.getItem('theme') === 'theme-light') {
            setTogClass('light')
        }
    }, [theme])

    return (
        <div className="container--toggle">
            {
                togClass === "light" ?
                <input type="checkbox" id="toggle" className="toggle--checkbox" onClick={handleOnClick} checked />
                :
                <input type="checkbox" id="toggle" className="toggle--checkbox" onClick={handleOnClick} />
            }
            <label htmlFor="toggle" className="toggle--label">
                <span className="toggle--label-background"></span>
            </label>
        </div>
    )
} Update To see how I have refactored the logic of this component and made it accessible, read . An Accessible Dark Mode Toggle in React Finally, my favorite part: the color switching SVGs! CSS variables work in SVG code too! I got my SVG code for the Github and Chrome icons from . For the Github icon all I had to change was one fill attribute in a : DEVICON <g> <g fill="var(--dark-text)"> The Chrome icon had a fill attribute in a and a : <circle> <path> <circle fill="var(--dark-text)" cx="63.624" cy="64.474" r="22.634"></circle><path fill="var(--dark-text)" ...> The result looks like this: Conclusion I tried to include all of the relevant code, but you can also see the full code for my site in its . If you enjoyed this article or are left with questions, please leave a comment! I would also love to see anything built following this tutorial. Github repository Also Published here

How to add a Dark Mode Toggle in React

This post will show you how to build the Feature Toggle mechanism in your Next.JS application. We are going to use Next.JS, React, and TypeScript. We will deploy our application to Vercel to demonstrate a real-life example. You can find the code and video in the summary at the end. What You'll Learn in This Article In this article, we are going to deep dive into several topics such as: What are feature toggles? How to use React's Context API What are environment variables, and how do we use them in our applications? How to build custom hooks in React. What Are Feature Toggles? Feature toggles (aka Feature Flags) are a technique that allows you to change the state of your application without modifying its code. In the beginning, it might sound a bit confusing but let's consider the following scenario: Every December, many companies change their logo to add a bit of holiday spirit. Perhaps they want to add a Santa Claus hat into their logos or some sort of snowman. Have you ever wondered if they change their website every year just to update the logo? No, in most cases, they only do it once, and just connected it into their feature toggle. So they can enable the special logo whenever they need it. Here's another example: imagine a development team that follows continuous integration (CI). They use this mechanism to commit unfinished code, and then merge it onto the main branch. The unfinished code is disabled in the production environment so users cannot see incomplete features. Keep in mind that this is only a good idea for mature development teams that have experienced developers on board along with automated checks for their CI pipelines (like automated tests, static code analysis, compilation / bundling, and so on). Before We Start This tutorial requires some Node and React fundamentals. You should also know how to use Git and GitHub before you follow the instructions in this article. I skipped the part about bootstrapping the example application since I showed a very similar process in one of my previous posts - . How to Build a Fully Functional Serverless App in Under Two Hours I created two GitHub repositories for this post. The first one contains the scaffolder of the application, so you can follow all steps of the tutorial on your own. The second one is the finished application which you can deploy to Vercel without writing any code if you would like just to see the end result. Application Scaffolder (GitHub). The final app, ready to deploy (GitHub). We'll build the example application using Next.JS, React, and Typescript. The main purpose of the application is to display two financial charts. The first one represents the GDP of the United States, and the second one shows Treasury Constant Maturity over the last 10 years. The second one is unfinished. Our goal is to hide it behind the feature toggle, so we can enable it whenever we need it. The final application should look like this: You can find it here. Let's Get Started! We need to clone the scaffolder repository from GitHub, and we can do that by typing the following command in the terminal: $ git clone git@github.com:mateuszsokola/next-feature-toggle-scaffolder.git Now we need install the required dependencies and start the server. $ cd next-feature-toggle-scaffolder
$ npm install
$ npm run dev Now you can open in your browser and see the following website: http://localhost:3000/ Now, how can we implement the Feature Toggle mechanism here? React's Context API seems to be the easiest and most appropriate way. What is the React Context API? The React Context API offers a neat and tidy way of passing data through multiple levels of components without doing it manually. Let's see the following example: <Page enabledFeatures={features} />
<PageLayout enabledFeatures={features} />
<NavigationBar enabledFeatures={features} />
<Link href="https://freecodecamp.org/news/">
  <Avatar enabledFeatures={features} />
</Link> If you don't want to use Context, you will need to pass the data as properties to every component. This is error-prone and cumbersome. If you decide to use the context, you can inject data directly into the component that actually needs it. Now we can create a context for our feature toggle. We need to create a directory called , and a new file inside this directory. We can call it . context/ FeatureToggleContext.ts $ mkdir context
$ cd context
$ touch FeatureToggleContext.ts Creating context in React is fairly easy. You need to import React in your file and call the React.createContext method with the default context value. See the example below: // file: context/FeatureToggleContext.ts
import React from "react";

export const FeatureToggleContext = React.createContext({
  // TypeScript will have hard time to determine its type,
  // if we don't cast this array to an array of strings.
  // Likely, we will end up with an array of never or any.
  enabledFeatures: [] as string[],
}); Have in mind that the default value is only used when the component isn't wrapped into the context provider. It is just a fallback, and it shouldn't be used without the provider. The Context Provider Component Context comes with a Provider component that allows consuming components to listen to context changes. The Provider component takes a value prop that you pass to components that are the children of this provider. In simple words, if we want to take advantage of the context we will need to make the Provider a parent of our all components. I decided to wrap the Provider into a standalone component so we don't clutter up other parts of the application. Let's create a new file in the directory called : components/ FeatureToggle.tsx $ cd components
$ touch FeatureToggle.tsx Now we can create a component that accepts two properties: and . children enabledFeatures The is the main component of the application. If you created a React app using you might have noticed that the main component is called . Next.JS calls it , and you can find it in the file . children create-react-app App MyApp pages/_app.tsx The is the array of enabled features. We will use it later. enabledFeatures # file: compontents/FeatureToggle.tsx

import React from "react";
import { FeatureToggleContext } from "../context/FeatureToggleContext";

type Props = {
    children: any;
    enabledFeatures: string[];
}

export const FeatureToggle = ({ children, enabledFeatures }: Props) => {
    return (
        <FeatureToggleContext.Provider value={{ enabledFeatures }}>
            {children}
        </FeatureToggleContext.Provider>
    )
} The wrapped component is ready. Now we need to hook it into the main component. Let's open the file pages/_app.tsx. We have only one toggleable feature – . We need to add it to the list of enabled features. At the moment, we'll soft code this list, and pass it down directly to the provider to confirm we have access to the context. Later on, we are going to create a proper API for the feature toggle. treasury_chart We need to modify the file to look like this: import { FeatureToggle } from "../components/FeatureToggle";
import "../styles/globals.css";

function MyApp({ Component, pageProps }) {
  const enabledFeatures = ["treasury_chart"];

  return ( 
    <FeatureToggle enabledFeatures={enabledFeatures}>
      <Component {...pageProps} />
    </FeatureToggle>
  );
}

export default MyApp; Technically, the list of enabled features is available in the whole application now. But we have no interface to consume its value. Taking advantage of React hooks is the best way to expose it. How to Create Custom Hooks in React We created this mechanism based on the React Context API, and the most React way to consume React Context is by using hooks. So we will need to create a hook that offers easy access to the right data in the context. Let's create a new directory called , and a new file called . hooks/ useFeatureToggle.ts $ mkdir hooks
$ touch useFeatureToggle.ts Let's think about the hook for a minute. We want to check the status of a given feature. If the feature is enabled we are going to render it, otherwise, we won't. So the hook should return a helper that checks if the requested feature is on the list of enabled features, right? Let's code it. # file: hooks/useFeatureToggle.ts

import React, { useContext } from "react";
import { FeatureToggleContext } from "../context/FeatureToggleContext";

export const useFeatureToggle = () => {
	// we need to read values defined in the FeatureToggleContext. 
    // In this case, we'll take only the array of enabled features.
    const { enabledFeatures } = useContext(FeatureToggleContext);

    const isEnabled = (featureName: string) => {
        return enabledFeatures.includes(featureName);
    }

	// For consistency, We return an array of helpers, 
    // so we follow the pattern defined by the useState hook.
    // It makes the code open for extensions, 
    // so no need to refactor the app when a new helper is added here.
    return [
        isEnabled,
    ];
} The hook is ready. We can open the main page, and connect the Treasury chart into the Feature Toggle. Let's open . pages/index.tsx We are going to use our custom hook to get access to the helper and use it to check if the feature is enabled. isEnabled const [isEnabled] = useFeatureToggle();

// ...

return (
  /* ... /
  {isEnabled("treasury_chart") && (<TreasuryChart />)}
  / ... */
); The complete implementation looks like this: # file: pages/index.tsx

import React from "react";
import Head from "next/head";
import { Layout } from "antd";

import { GdpChart, TreasuryChart } from "../components/Charts";
import { useFeatureToggle } from "../hooks/useFeatureToggle";

const { Header, Content } = Layout;

export default function Home() {
  const [isEnabled] = useFeatureToggle();
  return (
    <Layout className="layout">
      <Head>
        <title>🚦 Feature Toggle in Next.js</title>
      </Head>
      <Header>
        <div className="logo" />
      </Header>
      <Content className="content">
        <GdpChart />
        {isEnabled("treasury_chart") && (<TreasuryChart />)}
      </Content>
    </Layout>
  );
} Now, you can try out the application in your browser. Keep in mind that you will still see the second chart. You can fool around with the feature name given to the helper. For example, you can make a typo, and the chart should disappear afterwards. isEnabled Unfortunately, this solution doesn't give us flexibility to toggle features without modifying the codebase. Every time we want to change the status of the feature, we will need to modify the list of enabled features. How can we fix that? The easiest way to make it toggleable without changing the code would be to implement an API that reads statuses of features from environment variables and returns an array of active features. How to Use Environment Variables in Node An environment variable is a variable whose value is set outside the application, usually by functionality built into the operating system. This is Node.JS, in our case. Let's create a file in our project. .env $ touch .env Now, we can open this file and add a new variable. We can call it . We need to set its value to . FEATURE_TREASURY_CHART false # file: .env

FEATURE_TREASURY_CHART=false If we use .env variables we'll need to use some server features of Next.JS, and define a new API. This means we will need to write more code. So we need to create a new file in the directory. Let's call it . pages/api/ features.ts The API will return an array of enabled features. // file: pages/api/features.ts

export default (req, res) => {
    res.status(200).json([
    	// Your environment variables are available within the `process.env` object.
    	// IMPORTANT! All environment variable values are strings. 
        // So we cannot compare them with booleans, numbers and so on.
        process.env.FEATURE_TREASURY_CHART === "true" ? "treasury_chart" : "",
    ])
} Now, you can try to open in your browser, and you should receive the following output: http://localhost:3000/api/features [""] The wasn't added to the list of enabled features, because it is disabled. You can change the variable to , and restart your server to try it out. treasury_chart FEATURE_TREASURY_CHART true How to Use the Features API We are good to connect the React part of the application to our brand new API. Before we do so, we'll need to install . axios Axios will help us to make HTTP requests in a more convenient way than . It supports error handling and types out of the box. We don't need to implement it on our own, so we can get straight to business. You might need to kill your server by hitting Control + C. Twice. fetch $ npm install --save axios Let's create a new directory called , and a new file called . services/ FeatureToggle.ts Now we need to use a standard asynchronous function to make a GET request to our API. // File: services/FeatureToggle.ts

import axios from "axios";

export const fetchFeatures = async () => {
    try {
        const { data } = await axios.get<string[]>("/api/features");

        return data;
    }
    catch(e) {
        console.log("Something went wrong");
    }

    return [] as string[];
} OK. The feature API request is ready. We can actually trigger this function at the main component. Open the file . pages/_app.tsx We need to make an API request like every other in React using the and hooks. We need to add the following snippet to the component: useEffect useState MyApp const [enabledFeatures, setFeatures] = useState<string[]>([]);

  const processFeatures = async () => {
    const features = await fetchFeatures();

    setFeatures(features);
  }

  useEffect(() => {
    processFeatures();
  }, []); The complete solution is here: // file: pages/_app.tsx

import { useEffect, useState } from "react";
import { FeatureToggle } from "../components/FeatureToggleProvider";
import { fetchFeatures } from "../services/FeatureToggle";
import "../styles/globals.css";

function MyApp({ Component, pageProps }) {
  const [enabledFeatures, setFeatures] = useState<string[]>([]);

  const processFeatures = async () => {
    const features = await fetchFeatures();

    setFeatures(features);
  }

  useEffect(() => {
    processFeatures();
  }, []); // eslint-disable-line react-hooks/exhaustive-deps

  return (
    <FeatureToggle enabledFeatures={enabledFeatures}>
      <Component {...pageProps} />
    </FeatureToggle>
  )
}

export default MyApp; Hurray! We are done with coding. The final step is to deploy our app. How to Publish the App on Vercel We will deploy the application to Vercel, because they offer free hosting for apps and they let us set custom environment variables, which is critical for us. As usual, I am going to skip the process of creating a new account. You can create one with one click using your GitHub or Google account. Once you've signed up, you should see this screen. Click on the "New Project" button: Now you need to select the GitHub repository you want to import. In my case, it is "next-ft-demo", but you might've called it something else. If you don't see your repository, you need to click on "Adjust GitHub App Permission" (the link below marked with the red ellipse): We need to configure the project. Let's open "Environment Variables", add a new variable called FEATURE_TREASURY_CHART, and set its value to false. Then click on the "Add" button, and hit "Deploy": The application is being deployed now. You should see the following screen once done. Just click on the "Go To Dashboard" button: You can open your application by clicking the "Visit" button: The application displays only one chart: If you want to enable the Treasury chart you need to select the "Settings" tab, choose the "Environment variables" section, and set the FEATURE_TREASURY_CHART variable to true: Now we need to redeploy the application to load new variables. Once the deployment is completed you will see the Treasury chart on your website: Summary This is a simple implementation of Feature Toggles. You'll probably need to adjust it to fit your needs. But I think it's a good starting point that you can build upon. If you have an idea about how to improve my solution or you want to show us yet another way of doing it, please share it in the comment section of the YouTube video below (I reply to every comment). WATCH VIDEO ON YOUTUBE HERE If you find the video useful it would mean the world to me if you smash the like button and subscribe. You can find all the code on GitHub: Application Scaffolder (GitHub). The final app, ready to deploy (GitHub). If you have any questions you can DM me on Twitter: @msokola I hope you liked it and have a great day :) Also published on: https://www.freecodecamp.org/news/how-to-use-feature-toggles-in-next-js-and-react/

An Essential Guide to Feature Toggles Using Next.JS and React

Stop letting randomness dictate when you create. Many people say, “I’ll do it when I feel like it, when I have inspiration.” But professionals approach creativity differently. They don’t wait for inspiration to strike—they schedule it. As the saying goes, “I only write when I get inspiration. But inspiration comes every morning at 4 AM.” Here are five actionable steps to help you take control of inspiration: Set a Schedule:
Planning your day gives you a clear purpose—no ambiguity, only action. Without a plan, you rely on your mood or random circumstances to push you into action, which often leads to inconsistency.
When you schedule specific times for creative work, you replace chaos with order, ensuring steady progress. Use Progress Bars:
Many people depend on the dopamine rush from achieving outcomes. But this wait is often long and agonizing, causing many to give up before reaching their goals.
Here’s the secret: focus on the dopamine from the process, not just the outcome.Break your big goals into measurable, daily tasks. Example: Writing 100,000 words for a book becomes 700 words per day. Example: Designing 50 screens for a UI project becomes 1 screen per day. Tracking and celebrating daily progress keeps you motivated and productive while making the journey enjoyable. Become an Idea Sponge: Always collect and store ideas regularly. When it’s time to create, you’ll have a rich stack of concepts to expand on.
For example, Eminem keeps a catalog of lyrics and random bars to draw from.Writers do the same with thoughts, snippets, and observations. I’m using snippets from my own idea stack right now.Here’s a tip: schedule moments of boredom, like a walk or a break from consuming new information. The shower isn’t magical—it simply frees your mind to connect existing ideas and form new ones. Adjust Your Environment: The popular saying goes, “You can take a horse to water, but you can’t make it drink.” However, if you change the conditions—like withholding food, adding salt, or creating heat—the horse will drink.
Your environment can either nourish your creativity or drain it. Make adjustments that foster your creative habits.What changes can you make to your surroundings to inspire focus and action? Only you can answer this question, but observe your space and start experimenting. Toggle Pleasure and Pain: Discipline thrives when the pain of not achieving your goals outweighs the pleasure of distractions.
Use this principle to your advantage:Increase pleasure: Reward yourself after hitting milestones. For example, enjoy a favorite treat after completing 500 words or a SaaS project milestone. Increase pain: Set penalties for missed goals. If you don’t wake up on time, pay a friend $20. If you skip a creative session, automate an embarrassing tweet. These small shifts rewire your brain to associate positive emotions with discipline and negative emotions with procrastination.Bonus: Stick with It Consistency builds trust, speeds up your process, and makes creativity second nature.Think of an untidy room: cleaning after one day is easy, but waiting weeks or months makes it exponentially harder. The same applies to creativity—more entropy equals more effort to create order.By showing up consistently, you eliminate chaos and build momentum. With practice, creativity becomes a natural, enjoyable habit. Liked this post? Share it to help others escape the entropy trap. Enjoy the rest of your day. Stop letting randomness dictate when you create. Many people say, “I’ll do it when I feel like it, when I have inspiration.” But professionals approach creativity differently. They don’t wait for inspiration to strike—they schedule it. As the saying goes, “I only write when I get inspiration. But inspiration comes every morning at 4 AM.” Here are five actionable steps to help you take control of inspiration: Set a Schedule:
Planning your day gives you a clear purpose—no ambiguity, only action. Without a plan, you rely on your mood or random circumstances to push you into action, which often leads to inconsistency.
When you schedule specific times for creative work, you replace chaos with order, ensuring steady progress. Set a Schedule: Planning your day gives you a clear purpose—no ambiguity, only action. Without a plan, you rely on your mood or random circumstances to push you into action, which often leads to inconsistency. When you schedule specific times for creative work, you replace chaos with order, ensuring steady progress. Set a Schedule: Set a Schedule: Planning your day gives you a clear purpose—no ambiguity, only action. Without a plan, you rely on your mood or random circumstances to push you into action, which often leads to inconsistency. When you schedule specific times for creative work, you replace chaos with order, ensuring steady progress. Use Progress Bars:
Many people depend on the dopamine rush from achieving outcomes. But this wait is often long and agonizing, causing many to give up before reaching their goals.
Here’s the secret: focus on the dopamine from the process, not just the outcome.Break your big goals into measurable, daily tasks. Example: Writing 100,000 words for a book becomes 700 words per day. Example: Designing 50 screens for a UI project becomes 1 screen per day. Tracking and celebrating daily progress keeps you motivated and productive while making the journey enjoyable. Use Progress Bars: Many people depend on the dopamine rush from achieving outcomes. But this wait is often long and agonizing, causing many to give up before reaching their goals. Here’s the secret: focus on the dopamine from the process, not just the outcome. Break your big goals into measurable, daily tasks. Example: Writing 100,000 words for a book becomes 700 words per day. Example: Designing 50 screens for a UI project becomes 1 screen per day. Tracking and celebrating daily progress keeps you motivated and productive while making the journey enjoyable. Use Progress Bars: Use Progress Bars: Many people depend on the dopamine rush from achieving outcomes. But this wait is often long and agonizing, causing many to give up before reaching their goals. Here’s the secret: focus on the dopamine from the process, not just the outcome. Break your big goals into measurable, daily tasks. Example: Writing 100,000 words for a book becomes 700 words per day. Example: Designing 50 screens for a UI project becomes 1 screen per day. Tracking and celebrating daily progress keeps you motivated and productive while making the journey enjoyable. Become an Idea Sponge: Always collect and store ideas regularly. When it’s time to create, you’ll have a rich stack of concepts to expand on.
For example, Eminem keeps a catalog of lyrics and random bars to draw from.Writers do the same with thoughts, snippets, and observations. I’m using snippets from my own idea stack right now.Here’s a tip: schedule moments of boredom, like a walk or a break from consuming new information. The shower isn’t magical—it simply frees your mind to connect existing ideas and form new ones. Become an Idea Sponge: Always collect and store ideas regularly. When it’s time to create, you’ll have a rich stack of concepts to expand on. For example, Eminem keeps a catalog of lyrics and random bars to draw from. Writers do the same with thoughts, snippets, and observations. I’m using snippets from my own idea stack right now. Here’s a tip: schedule moments of boredom, like a walk or a break from consuming new information. The shower isn’t magical—it simply frees your mind to connect existing ideas and form new ones. Become an Idea Sponge: Always collect and store ideas regularly. When it’s time to create, you’ll have a rich stack of concepts to expand on. Become an Idea Sponge: For example, Eminem keeps a catalog of lyrics and random bars to draw from. Writers do the same with thoughts, snippets, and observations. I’m using snippets from my own idea stack right now. Here’s a tip: schedule moments of boredom, like a walk or a break from consuming new information. The shower isn’t magical—it simply frees your mind to connect existing ideas and form new ones. Adjust Your Environment: The popular saying goes, “You can take a horse to water, but you can’t make it drink.” However, if you change the conditions—like withholding food, adding salt, or creating heat—the horse will drink.
Your environment can either nourish your creativity or drain it. Make adjustments that foster your creative habits.What changes can you make to your surroundings to inspire focus and action? Only you can answer this question, but observe your space and start experimenting. Adjust Your Environment: The popular saying goes, “You can take a horse to water, but you can’t make it drink.” However, if you change the conditions—like withholding food, adding salt, or creating heat—the horse will drink. Your environment can either nourish your creativity or drain it. Make adjustments that foster your creative habits. What changes can you make to your surroundings to inspire focus and action? Only you can answer this question, but observe your space and start experimenting. Adjust Your Environment: The popular saying goes, “You can take a horse to water, but you can’t make it drink.” However, if you change the conditions—like withholding food, adding salt, or creating heat—the horse will drink. Adjust Your Environment: Your environment can either nourish your creativity or drain it. Make adjustments that foster your creative habits. What changes can you make to your surroundings to inspire focus and action? Only you can answer this question, but observe your space and start experimenting. Toggle Pleasure and Pain: Discipline thrives when the pain of not achieving your goals outweighs the pleasure of distractions.
Use this principle to your advantage:Increase pleasure: Reward yourself after hitting milestones. For example, enjoy a favorite treat after completing 500 words or a SaaS project milestone. Increase pain: Set penalties for missed goals. If you don’t wake up on time, pay a friend $20. If you skip a creative session, automate an embarrassing tweet. These small shifts rewire your brain to associate positive emotions with discipline and negative emotions with procrastination.Bonus: Stick with It Consistency builds trust, speeds up your process, and makes creativity second nature.Think of an untidy room: cleaning after one day is easy, but waiting weeks or months makes it exponentially harder. The same applies to creativity—more entropy equals more effort to create order.By showing up consistently, you eliminate chaos and build momentum. With practice, creativity becomes a natural, enjoyable habit. Toggle Pleasure and Pain: Discipline thrives when the pain of not achieving your goals outweighs the pleasure of distractions. Use this principle to your advantage: Increase pleasure: Reward yourself after hitting milestones. For example, enjoy a favorite treat after completing 500 words or a SaaS project milestone. Increase pain: Set penalties for missed goals. If you don’t wake up on time, pay a friend $20. If you skip a creative session, automate an embarrassing tweet. These small shifts rewire your brain to associate positive emotions with discipline and negative emotions with procrastination. Bonus: Stick with It Consistency builds trust, speeds up your process, and makes creativity second nature. Think of an untidy room: cleaning after one day is easy, but waiting weeks or months makes it exponentially harder. The same applies to creativity—more entropy equals more effort to create order. By showing up consistently, you eliminate chaos and build momentum. With practice, creativity becomes a natural, enjoyable habit. Toggle Pleasure and Pain: Discipline thrives when the pain of not achieving your goals outweighs the pleasure of distractions. Toggle Pleasure and Pain: Use this principle to your advantage: Increase pleasure: Reward yourself after hitting milestones. For example, enjoy a favorite treat after completing 500 words or a SaaS project milestone. Increase pain: Set penalties for missed goals. If you don’t wake up on time, pay a friend $20. If you skip a creative session, automate an embarrassing tweet. These small shifts rewire your brain to associate positive emotions with discipline and negative emotions with procrastination. Bonus: Stick with It Consistency builds trust, speeds up your process, and makes creativity second nature. Bonus: Think of an untidy room: cleaning after one day is easy, but waiting weeks or months makes it exponentially harder. The same applies to creativity—more entropy equals more effort to create order. By showing up consistently, you eliminate chaos and build momentum. With practice, creativity becomes a natural, enjoyable habit. Liked this post? Share it to help others escape the entropy trap. Enjoy the rest of your day.

Stories, News & Mentions about TOGGLE

Toggle’s Stories on HackerNoon