• Stars
    star
    385
  • Rank 107,863 (Top 3 %)
  • Language
  • Created over 1 year ago
  • Updated 2 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

A curated list of awesome 🔥 TypeScript Tips 🔥

Typescript Tips Awesome

A curated list of awesome 🔥 TypeScript Tips 🔥

If you enjoy TypeScript and really want to use Typesafe, you can check awesome-typesafe

🏠 Homepage

Gitbook

Contents

Tips

Matt Pocock

Wes Bos

Erik Rasmussen

Carlos Caballero

Ankita Kulkarni

Minko Gechev

Cory House

Tomek Sułkowski

Sebastien Lorber

Steve (Builder.io)

StackBlitz

Extending existing types

  • PackageJson - There are a lot of tools that place extra configurations inside the package.json file. You can extend PackageJson to support these additional configurations.

    Example

    Playground

    import type { PackageJson as BasePackageJson } from "type-fest";
    import type { Linter } from "eslint";
    
    type PackageJson = BasePackageJson & { eslintConfig?: Linter.Config };

Built-in types

There are many advanced types most users don't know about.

  • Partial<T> - Make all properties in T optional.

    Example

    Playground

    interface NodeConfig {
      appName: string;
      port: number;
    }
    
    class NodeAppBuilder {
      private configuration: NodeConfig = {
        appName: "NodeApp",
        port: 3000,
      };
    
      private updateConfig<Key extends keyof NodeConfig>(
        key: Key,
        value: NodeConfig[Key]
      ) {
        this.configuration[key] = value;
      }
    
      config(config: Partial<NodeConfig>) {
        type NodeConfigKey = keyof NodeConfig;
    
        for (const key of Object.keys(config) as NodeConfigKey[]) {
          const updateValue = config[key];
    
          if (updateValue === undefined) {
            continue;
          }
    
          this.updateConfig(key, updateValue);
        }
    
        return this;
      }
    }
    
    // `Partial<NodeConfig>`` allows us to provide only a part of the
    // NodeConfig interface.
    new NodeAppBuilder().config({ appName: "ToDoApp" });
  • Required<T> - Make all properties in T required.

    Example

    Playground

    interface ContactForm {
      email?: string;
      message?: string;
    }
    
    function submitContactForm(formData: Required<ContactForm>) {
      // Send the form data to the server.
    }
    
    submitContactForm({
      email: "[email protected]",
      message: "Hi! Could you tell me more about�",
    });
    
    // TypeScript error: missing property 'message'
    submitContactForm({
      email: "[email protected]",
    });
  • Readonly<T> - Make all properties in T readonly.

    Example

    Playground

    enum LogLevel {
      Off,
      Debug,
      Error,
      Fatal,
    }
    
    interface LoggerConfig {
      name: string;
      level: LogLevel;
    }
    
    class Logger {
      config: Readonly<LoggerConfig>;
    
      constructor({ name, level }: LoggerConfig) {
        this.config = { name, level };
        Object.freeze(this.config);
      }
    }
    
    const config: LoggerConfig = {
      name: "MyApp",
      level: LogLevel.Debug,
    };
    
    const logger = new Logger(config);
    
    // TypeScript Error: cannot assign to read-only property.
    logger.config.level = LogLevel.Error;
    
    // We are able to edit config variable as we please.
    config.level = LogLevel.Error;
  • Pick<T, K> - From T, pick a set of properties whose keys are in the union K.

    Example

    Playground

    interface Article {
      title: string;
      thumbnail: string;
      content: string;
    }
    
    // Creates new type out of the `Article` interface composed
    // from the Articles' two properties: `title` and `thumbnail`.
    // `ArticlePreview = {title: string; thumbnail: string}`
    type ArticlePreview = Pick<Article, "title" | "thumbnail">;
    
    // Render a list of articles using only title and description.
    function renderArticlePreviews(previews: ArticlePreview[]): HTMLElement {
      const articles = document.createElement("div");
    
      for (const preview of previews) {
        // Append preview to the articles.
      }
    
      return articles;
    }
    
    const articles = renderArticlePreviews([
      {
        title: "TypeScript tutorial!",
        thumbnail: "/assets/ts.jpg",
      },
    ]);
  • Record<K, T> - Construct a type with a set of properties K of type T.

    Example

    Playground

    // Positions of employees in our company.
    type MemberPosition = "intern" | "developer" | "tech-lead";
    
    // Interface describing properties of a single employee.
    interface Employee {
      firstName: string;
      lastName: string;
      yearsOfExperience: number;
    }
    
    // Create an object that has all possible `MemberPosition` values set as keys.
    // Those keys will store a collection of Employees of the same position.
    const team: Record<MemberPosition, Employee[]> = {
      intern: [],
      developer: [],
      "tech-lead": [],
    };
    
    // Our team has decided to help John with his dream of becoming Software Developer.
    team.intern.push({
      firstName: "John",
      lastName: "Doe",
      yearsOfExperience: 0,
    });
    
    // `Record` forces you to initialize all of the property keys.
    // TypeScript Error: "tech-lead" property is missing
    const teamEmpty: Record<MemberPosition, null> = {
      intern: null,
      developer: null,
    };
  • Exclude<T, U> - Exclude from T those types that are assignable to U.

    Example

    Playground

    interface ServerConfig {
      port: null | string | number;
    }
    
    type RequestHandler = (request: Request, response: Response) => void;
    
    // Exclude `null` type from `null | string | number`.
    // In case the port is equal to `null`, we will use default value.
    function getPortValue(port: Exclude<ServerConfig["port"], null>): number {
      if (typeof port === "string") {
        return parseInt(port, 10);
      }
    
      return port;
    }
    
    function startServer(handler: RequestHandler, config: ServerConfig): void {
      const server = require("http").createServer(handler);
    
      const port = config.port === null ? 3000 : getPortValue(config.port);
      server.listen(port);
    }
  • Extract<T, U> - Extract from T those types that are assignable to U.

    Example

    Playground

    declare function uniqueId(): number;
    
    const ID = Symbol("ID");
    
    interface Person {
      [ID]: number;
      name: string;
      age: number;
    }
    
    // Allows changing the person data as long as the property key is of string type.
    function changePersonData<
      Obj extends Person,
      Key extends Extract<keyof Person, string>,
      Value extends Obj[Key]
    >(obj: Obj, key: Key, value: Value): void {
      obj[key] = value;
    }
    
    // Tiny Andrew was born.
    const andrew = {
      [ID]: uniqueId(),
      name: "Andrew",
      age: 0,
    };
    
    // Cool, we're fine with that.
    changePersonData(andrew, "name", "Pony");
    
    // Goverment didn't like the fact that you wanted to change your identity.
    changePersonData(andrew, ID, uniqueId());
  • NonNullable<T> - Exclude null and undefined from T.

    Example Works with strictNullChecks set to true.

    Playground

    type PortNumber = string | number | null;
    
    /** Part of a class definition that is used to build a server */
    class ServerBuilder {
      portNumber!: NonNullable<PortNumber>;
    
      port(this: ServerBuilder, port: PortNumber): ServerBuilder {
        if (port == null) {
          this.portNumber = 8000;
        } else {
          this.portNumber = port;
        }
    
        return this;
      }
    }
    
    const serverBuilder = new ServerBuilder();
    
    serverBuilder
      .port("8000") // portNumber = '8000'
      .port(null) // portNumber =  8000
      .port(3000); // portNumber =  3000
    
    // TypeScript error
    serverBuilder.portNumber = null;
  • Parameters<T> - Obtain the parameters of a function type in a tuple.

    Example

    Playground

    function shuffle(input: any[]): void {
      // Mutate array randomly changing its' elements indexes.
    }
    
    function callNTimes<Fn extends (...args: any[]) => any>(
      func: Fn,
      callCount: number
    ) {
      // Type that represents the type of the received function parameters.
      type FunctionParameters = Parameters<Fn>;
    
      return function (...args: FunctionParameters) {
        for (let i = 0; i < callCount; i++) {
          func(...args);
        }
      };
    }
    
    const shuffleTwice = callNTimes(shuffle, 2);
  • ConstructorParameters<T> - Obtain the parameters of a constructor function type in a tuple.

    Example

    Playground

    class ArticleModel {
      title: string;
      content?: string;
    
      constructor(title: string) {
        this.title = title;
      }
    }
    
    class InstanceCache<T extends new (...args: any[]) => any> {
      private ClassConstructor: T;
      private cache: Map<string, InstanceType<T>> = new Map();
    
      constructor(ctr: T) {
        this.ClassConstructor = ctr;
      }
    
      getInstance(...args: ConstructorParameters<T>): InstanceType<T> {
        const hash = this.calculateArgumentsHash(...args);
    
        const existingInstance = this.cache.get(hash);
        if (existingInstance !== undefined) {
          return existingInstance;
        }
    
        return new this.ClassConstructor(...args);
      }
    
      private calculateArgumentsHash(...args: any[]): string {
        // Calculate hash.
        return "hash";
      }
    }
    
    const articleCache = new InstanceCache(ArticleModel);
    const amazonArticle = articleCache.getInstance("Amazon forests burining!");
  • ReturnType<T> - Obtain the return type of a function type.

    Example

    Playground

    /** Provides every element of the iterable `iter` into the `callback` function and stores the results in an array. */
    function mapIter<
      Elem,
      Func extends (elem: Elem) => any,
      Ret extends ReturnType<Func>
    >(iter: Iterable<Elem>, callback: Func): Ret[] {
      const mapped: Ret[] = [];
    
      for (const elem of iter) {
        mapped.push(callback(elem));
      }
    
      return mapped;
    }
    
    const setObject: Set<string> = new Set();
    const mapObject: Map<number, string> = new Map();
    
    mapIter(setObject, (value: string) => value.indexOf("Foo")); // number[]
    
    mapIter(mapObject, ([key, value]: [number, string]) => {
      return key % 2 === 0 ? value : "Odd";
    }); // string[]
  • InstanceType<T> - Obtain the instance type of a constructor function type.

    Example

    Playground

    class IdleService {
      doNothing(): void {}
    }
    
    class News {
      title: string;
      content: string;
    
      constructor(title: string, content: string) {
        this.title = title;
        this.content = content;
      }
    }
    
    const instanceCounter: Map<Function, number> = new Map();
    
    interface Constructor {
      new (...args: any[]): any;
    }
    
    // Keep track how many instances of `Constr` constructor have been created.
    function getInstance<
      Constr extends Constructor,
      Args extends ConstructorParameters<Constr>
    >(constructor: Constr, ...args: Args): InstanceType<Constr> {
      let count = instanceCounter.get(constructor) || 0;
    
      const instance = new constructor(...args);
    
      instanceCounter.set(constructor, count + 1);
    
      console.log(`Created ${count + 1} instances of ${Constr.name} class`);
    
      return instance;
    }
    
    const idleService = getInstance(IdleService);
    // Will log: `Created 1 instances of IdleService class`
    const newsEntry = getInstance(
      News,
      "New ECMAScript proposals!",
      "Last month..."
    );
    // Will log: `Created 1 instances of News class`
  • Omit<T, K> - Constructs a type by picking all properties from T and then removing K.

    Example

    Playground

    interface Animal {
      imageUrl: string;
      species: string;
      images: string[];
      paragraphs: string[];
    }
    
    // Creates new type with all properties of the `Animal` interface
    // except 'images' and 'paragraphs' properties. We can use this
    // type to render small hover tooltip for a wiki entry list.
    type AnimalShortInfo = Omit<Animal, "images" | "paragraphs">;
    
    function renderAnimalHoverInfo(animals: AnimalShortInfo[]): HTMLElement {
      const container = document.createElement("div");
      // Internal implementation.
      return container;
    }
  • Uppercase<S extends string> - Transforms every character in a string into uppercase.

    Example
    type T = Uppercase<"hello">; // 'HELLO'
    
    type T2 = Uppercase<"foo" | "bar">; // 'FOO' | 'BAR'
    
    type T3<S extends string> = Uppercase<`aB${S}`>;
    type T4 = T3<"xYz">; // 'ABXYZ'
    
    type T5 = Uppercase<string>; // string
    type T6 = Uppercase<any>; // any
    type T7 = Uppercase<never>; // never
    type T8 = Uppercase<42>; // Error, type 'number' does not satisfy the constraint 'string'
  • Lowercase<S extends string> - Transforms every character in a string into lowercase.

    Example
    type T = Lowercase<"HELLO">; // 'hello'
    
    type T2 = Lowercase<"FOO" | "BAR">; // 'foo' | 'bar'
    
    type T3<S extends string> = Lowercase<`aB${S}`>;
    type T4 = T3<"xYz">; // 'abxyz'
    
    type T5 = Lowercase<string>; // string
    type T6 = Lowercase<any>; // any
    type T7 = Lowercase<never>; // never
    type T8 = Lowercase<42>; // Error, type 'number' does not satisfy the constraint 'string'
  • Capitalize<S extends string> - Transforms the first character in a string into uppercase.

    Example
    type T = Capitalize<"hello">; // 'Hello'
    
    type T2 = Capitalize<"foo" | "bar">; // 'Foo' | 'Bar'
    
    type T3<S extends string> = Capitalize<`aB${S}`>;
    type T4 = T3<"xYz">; // 'ABxYz'
    
    type T5 = Capitalize<string>; // string
    type T6 = Capitalize<any>; // any
    type T7 = Capitalize<never>; // never
    type T8 = Capitalize<42>; // Error, type 'number' does not satisfy the constraint 'string'
  • Uncapitalize<S extends string> - Transforms the first character in a string into lowercase.

    Example
    type T = Uncapitalize<"Hello">; // 'hello'
    
    type T2 = Uncapitalize<"Foo" | "Bar">; // 'foo' | 'bar'
    
    type T3<S extends string> = Uncapitalize<`AB${S}`>;
    type T4 = T3<"xYz">; // 'aBxYz'
    
    type T5 = Uncapitalize<string>; // string
    type T6 = Uncapitalize<any>; // any
    type T7 = Uncapitalize<never>; // never
    type T8 = Uncapitalize<42>; // Error, type 'number' does not satisfy the constraint 'string'

You can find some examples in the TypeScript docs.

Contribute

Contributions welcome! Read the contribution guidelines first.

Twitter to markdown file

Create .envrc and fill the value then Use tweet-to-markdown

# .envrc
export TTM_API_KEY=YOUR_API_KEY

Then run the direnv command

 direnv allow .

And, generate markdown from a twitter url

npx tweet-to-markdown -p notes https://twitter.com/mattpocockuk/status/1509964736275927042\?s\=20\&t\=sA-g5MNM5TPjN6Ozs1qxgA

Then save video if available

npx twt-dl-cli@latest https://twitter.com/mattpocockuk/status/1592130978234900484

Finally, add the Thread Reader App at the end with below format.

[Thread by @USERNAME on Threadify Reader App](https://threadify.productsway.com/thread/STATUS_ID)

NOTE: I have sent a pull request about this step to tweet-to-markdown repository: feat: add Thread Reader App link and the end #19 Might not need this step if this PR is accepted.

Credits

This project is made by community and especially the wonderful people and projects listed in this document

Open Source

Tech Twitter

Author

👤 Huynh Duc Dung

Show your support

Give a ⭐️ if this project helped you!

kofi paypal buymeacoffee

Stargazers

Stargazers repo roster for @jellydn/typescript-tips

Stargazers over time

Stargazers over time

More Repositories

1

next-swagger-doc

This package reads your JSDoc-annotated source code on NextJS API route and generates an OpenAPI (Swagger) specification.
TypeScript
375
star
2

dapp-starter

Opinionated Dapp Starter Template provides a solid foundation for building Ethereum-based applications. It incorporates various tools and frameworks such as React, Next.js, Hardhat, TypeChain, web3-react, daisyUI Tailwind CSS Components, and OpenZeppelin.
TypeScript
309
star
3

nft-app

How to create your own NFT and mint NFT token
TypeScript
210
star
4

next-app-starter

Another awesome starter for your app base on nextjs + tailwind + react-query + zod + react-hook-form + next-auth + jotai
TypeScript
176
star
5

dapp-token-ico

How to do your first ICO smart contract
TypeScript
124
star
6

hurl.nvim

Hurl.nvim is a Neovim plugin designed to run HTTP requests directly from `.hurl` files. Elevate your API development workflow by executing and viewing responses without leaving your editor.
Lua
91
star
7

fastify-starter

Fastify starter template support RestAPI with Swagger and Graphql
TypeScript
87
star
8

gpt4free-demo

A slow guide on setting up a free OpenAI GPT-4 API on your local machine.
TypeScript
86
star
9

lazy-nvim-ide

My 💤 LazyVim IDE config for Neovim
Lua
56
star
10

awesome-typesafe

A curated list of awesome 🔥 TypeScript Typesafe Libraries🔥
49
star
11

react-dapp

Dapp Example with ERC20 Token and Simple Greeter Contract. Built with Hardhat + EthersJs + React + TypeScript.
TypeScript
47
star
12

next-validations

NextJS API Validations, support Zod, Yup, Fastest-Validator, Joi, and more
TypeScript
42
star
13

grpc-demo-monorepo

NodeJS/Go + gRPC/Connect + NextJS
TypeScript
39
star
14

gpt4all-cli

By utilizing GPT4All-CLI, developers can effortlessly tap into the power of GPT4All and LLaMa without delving into the library's intricacies. Simply install the CLI tool, and you're prepared to explore the fascinating world of large language models directly from your command line!
TypeScript
33
star
15

new-web-app

Frontend app generator, built on top vitejs
TypeScript
29
star
16

elysia-demo-app

A Real-World Example Using Bun, Docker, and Fly.io 🚀
TypeScript
27
star
17

nvim-for-webdev

Starter Template for Web Developers
Lua
25
star
18

twt-dl-cli

The easiest way to download any Twitter video from CLI
TypeScript
18
star
19

llama2-personal-ai

Build your personal AI with the llama2 model 🤖. Easy to use, and perfect for your development needs!
16
star
20

trpc-demo

Monorepo for tRPC v9 Demo Apps
TypeScript
16
star
21

moleculer-typescript-template

This is a Moleculer-based microservices project
TypeScript
12
star
22

auto-testgen-nodejs

How to use AI to generate unit tests
TypeScript
11
star
23

thirdweb-foundry-starter

Third Web Foundry Stater Template
Solidity
11
star
24

ts-inlay-hints

A guide on how to utilize TypeScript inlay hints in VS Code / Neovim with the TypeScript Language Server
TypeScript
10
star
25

playwright-crawler-demo

This template is a production ready boilerplate for developing with `PlaywrightCrawler`. Use this to bootstrap your projects using the most up-to-date code.
Dockerfile
10
star
26

learn-nextjs14-dashboard

Learn NextJs 14 App
TypeScript
9
star
27

learn-vim-with-vscode

This project aims to guide you through setting up and learning Vim within Visual Studio Code using the VSCodeVim and VSCode-Neovim extensions.
Lua
8
star
28

react-tips-2022-demo

Tips for ReactJs in 2022
TypeScript
8
star
29

mailwind-demo

Use Tailwind CSS to design HTML emails.
JavaScript
7
star
30

vite-react-seo-demo

Simple SEO implement with React + React-Snap
TypeScript
7
star
31

svelte-kit-demo

Simple setup with Svelte-kit with tailwind,graphql, and deployment to Vercel/Firebase
Svelte
7
star
32

promise-should-be-fun

Collection of exercises designed to practice and improve your skills with async programming in JavaScript.
TypeScript
7
star
33

my-note.nvim

MyNote is a Neovim plugin that allows you to take notes in a floating window
Lua
6
star
34

tx-revert-reason

Get the revert reason from an Ethereum transaction hash
TypeScript
6
star
35

github-action-locally

How to run GitHub Action locally with act.
TypeScript
6
star
36

quick-code-runner.nvim

A simple and efficient code runner for Neovim.
Lua
6
star
37

ws-sockette

The little WebSocket wrapper for nodejs
TypeScript
5
star
38

eslint-config-productsway

Enhance your code quality with XO's ESLint config, further augmented with TypeScript and Prettier support.
JavaScript
5
star
39

nvim-ide

Personal IDE config for Neovim
Lua
5
star
40

summary-chatbot-demo

🤖 Build an intelligent Summary ChatBot with AI technologies. Simplify content extraction and make summarisation easy.
TypeScript
5
star
41

cspell-tool

Keep your project's spelling in check with cspell-tool.
TypeScript
5
star
42

express-vercel-starter

Express.js v5 starter is a boilerplate for building and deploying Express.js applications to Vercel.
TypeScript
5
star
43

wallet-connect-app

The best way to connect a wallet
TypeScript
5
star
44

vite-react-recoil

Simple demo for react + recoil + react-hook-form
TypeScript
5
star
45

use-wait-for-transaction-hash

Simple hook for getting transaction status from the ETH network.
TypeScript
5
star
46

platformatic-starter

Platformatic starter template
TypeScript
4
star
47

hono-minimal-app

This is a minimal project with honojs
TypeScript
4
star
48

react-18-demo

TypeScript
4
star
49

edge-network-demo

Edge Network Demo
TypeScript
4
star
50

itman-channel

My weekly video on IT Man Channel
TypeScript
4
star
51

react-email-starter

React Email Starter
TypeScript
4
star
52

copilot-tips

Learn how to improve your code with Github Copilot
JavaScript
4
star
53

typechain-demo-app

How to use Typechain with Ethers V5
TypeScript
4
star
54

bnb-testnet-auto-faucet

TypeScript
4
star
55

next-demo-app

The real example app with nextjs (NextJS + Tailwind + Form + Data fetching ...)
TypeScript
4
star
56

hyperstack-demo-app

HTML
4
star
57

modern-python-2024-demo

Modern development with Python in 2024
Python
4
star
58

lens-demo-app

Lens Demo App
TypeScript
3
star
59

demo-chat-bot

Develop chatbots with zero configuration using typescript
TypeScript
3
star
60

typescript-starter

Typescript starter project
TypeScript
3
star
61

chatbot-starter-app

Develop chatbot with zero configuration using typescript
TypeScript
3
star
62

go-react-blog-app

TypeScript
3
star
63

untypeable-wretch-demo

This is a demo project that showcases how to use the Untypeable library with Wretch to make API requests to JsonPlaceholder and display the data on a webpage.
TypeScript
3
star
64

eth-cli

How to test smart contract in CLI like a PRO
Solidity
3
star
65

react-18-migration-demo

How to Upgrade to React 18
TypeScript
3
star
66

fresh-deno-app

A fresh (deno) app
TypeScript
3
star
67

dotfiles

A set of vim, zsh, git configuration files and tools.
Shell
3
star
68

typecheck.nvim

A Neovim plugin for seamless TypeScript type checking.
Lua
3
star
69

sharing-btn

Sharing Button - Web Component using Stencil
TypeScript
3
star
70

huma-demo

A modern, simple, fast & flexible micro framework for building HTTP REST/RPC APIs in Golang backed by OpenAPI 3 and JSON Schema.
Go
3
star
71

nestjs-7day-journey

NestJourney: Embark on a 7-day journey through the realm of Nest.js. This journey is designed for experienced developers looking to boost their Node.js skills with Nest.js.
TypeScript
3
star
72

learn-tdd-with-katas

a monorepo that demonstrates Test-Driven Development (TDD) using Turbo, pnpm, Moleculer (a microservices framework), and TypeORM (an ORM for TypeScript and JavaScript)
TypeScript
3
star
73

hapi-demo

A simple Hapi server for demonstration purposes, designed to work with Hurl for testing HTTP requests.
TypeScript
2
star
74

flutter-apprentice

Dart
2
star
75

typescript-mini-starter

A streamlined and efficient TypeScript starter kit, supporting both ESM and CJS, for quick and versatile project setups.
TypeScript
2
star
76

better-async-demo

Easy to handle the async await without try catch
TypeScript
2
star
77

ts-pattern-demo-app

A state reducer example with ts-pattern with React App
TypeScript
2
star
78

deno-pkg-starter

Publish your Typescript library to NPM and Deno
TypeScript
2
star
79

moleculer-connect

A command-line interface for connecting to Moleculer microservices
TypeScript
2
star
80

react-lib-starter

React Lib Starter Template
TypeScript
2
star
81

waku-rsc-async-demo

TypeScript
2
star
82

floating-promise-demo

How to handle floating promises in JavaScript
TypeScript
2
star
83

stepci-demo

A slow guide to set up continuous integration for a Fastify using StepCI.
TypeScript
2
star
84

jellydn

TypeScript
2
star
85

justext

Program jusText is a tool for removing boilerplate content, such as navigation links, headers, and footers from HTML pages.
JavaScript
2
star
86

ethers-bignumber-demo

How to convert to BigNumber's ethers.js without error.
TypeScript
2
star
87

indie-stack-simple-notes

Remix Indie Stack - Simple notes app
TypeScript
2
star
88

i18n-react-app

TypeScript
2
star
89

pkg-cli-simple-app

Demo pkg app
TypeScript
2
star
90

remix-spa-demo

How to use Biome with Bun.js and Remix to create a Single Page Application
TypeScript
2
star
91

spinner.nvim

spinner.nvim is a single file, no-dependency plugin for Neovim
Lua
2
star
92

firebolt-grit-demo

Quickly build high performance, efficient, full-stack apps on the web.
JavaScript
2
star
93

encore-demo-app

Encore Demo App
Go
1
star
94

laravel-demo-app

Exploring the cutting edge of PHP development on MacOSX in 2023
PHP
1
star
95

xata-astro

Astro Blog with Xata
Astro
1
star
96

hello-near-app

JavaScript
1
star
97

bun-dx-tips

Embark on a streamlined journey with Bun, unraveling a collection of simple yet impactful tips to elevate your development experience
TypeScript
1
star
98

blog

My personal blog
TypeScript
1
star
99

react-users-crud-demo

Simple SPA for users management with ReactJS
JavaScript
1
star
100

preact-signal-demo

Simple demo with Preact Signal for react app
TypeScript
1
star