• The simplest Svelte component is an empty file

    Aug 4 2019

    I discovered something while refactoring my Svelte code that blew my mind:

    This was very useful during refactoring, because I could just create a placeholder file for the new component, import it and start using it:

    <script>
    import Empty from './empty.svelte';
    </script>
    
    <Empty/>
    

    Sure, it doesn't do anything, but it doesn't break either.

    I think this is very symbolic of what makes Svelte so groundbreaking and powerful. Let's dig deeper and see what it can teach us about Svelte.

    A Svelte component is a file

    With Svelte, components and files have a one-to-one relationship. Every file is a component, and files can't have more than one component. This is generally a "best practice" when using most component frameworks. Perhaps this practice comes from the practice of having each class in a separate file in languages like Java or C++.

    By enforcing this practice, Svelte can make some assumptions that simplify your code. That brings me to the next observation.

    No boilerplate, just make a new file

    In most component frameworks, you need to write some code to define your component. With React, the simplest component is an empty function. In other frameworks, you need to import a library and call a special function to define and create your component. With Svelte, you just create a new .svelte file.

    The Svelte compiler will take each file and generate a component for it automatically. And that brings us to another important observation.

    You don't need Svelte to use a Svelte component

    In order to mount a React component, you need to import react-dom. Using a Vue component requires the Vue library. An Angular application absolutely requires loading the Angular framework.

    Svelte, on the other hand, is a compiler. In a way, Svelte is more like a programming language than a library. When you're programming in JavaScript, you don't need to import something to use a for loop. Similarly, you don't need to import anything in your Svelte code to use Svelte's template syntax. Your Svelte files get compiled into Javascript and CSS. It's a very different approach.

    You might guess that an empty file would compile into an empty JavaScript file, but every Svelte component comes with an API that allows you to use it outside of Svelte and mount it into the DOM. Here's what it looks like to use a compiled Svelte component:

    import Empty from './empty.js';
    
    const empty = new Empty({
      target: document.body,
      props: {
          // if we had some, they'd go here
      }
    });
    

    If we compile our empty component and bundle it with Svelte internals, it ends up being 2,080 bytes uncompressed, and 1,043 bytes gzipped. So the overhead for using Svelte ends up being only a kilobyte. Compare that to other frameworks that require 10x or 100x that many bytes just to mount an empty component!

    Svelte is a new paradigm

    At first glance, being able to use an empty file as a component seems like a silly, impractical gimmick. But looking deeper, I think it teaches us a lot about how Svelte differs from most if not all JavaScript component frameworks that came before it.

    I imagine it will inspire other framework developers to take a similar approach and reap some of the same benefits. This is the kind of shift in thinking that changes things permanently. Svelte is not just a new framework, but a complete paradigm shift.