There is currently a support for go, kotlin, python and typescript. It is very interesting, because it takes over one reason why ORMs are used (with migration handling and security).

The documentation is available at https://docs.sqlc.dev/en/latest/

An alternative to NPM. It looks interesting because it does more than NPM for authors.

Compared to NPM, JSR has native typescript support, ESM Syntax, and some better contraints for interoperability.

More on https://jsr.io/docs/why

Similar to https://shaarli.lyokolux.space/shaare/xwiTHQ

Bit operators are the fastest, then static array, then dynamic arrays.

Objects are heavy in comparison.

It aims to eliminate the complexity and redundant boilerplate code when building a federated server app, so that you can focus on your business logic and user experience.m

The announcement for 1.0 is there: https://github.com/dahlia/fedify/discussions/141

Minimalistic web application designed for sending end-to-end encrypted notes and files.

Github project: https://github.com/CorentinTh/enclosed/tree/main

While using Vite, the vite paths configuration can support the typescript aliases with the plugin vite-tsconfig-paths

export type Result<T, E> = { ok: true, result?: T } | { ok: false, err: E }

Advantages: everything.
Disadvantages: it creates an object for it.

It is a quick way to test it before using a small library https://shaarli.lyokolux.space/?NJ9Efg

aria-label and aria-labelledby are exclusive. So they can be enforced for components in typescript:

type ToggleSwitchProps = {
  name: string;
  checked: boolean;
  handleToggle: () => void;
  size?: "sm" | "lg" | "base";
  classNames?: string;
} & ({ ariaLabel: string; ariaLabelledBy: never } | { ariaLabel: never; ariaLabelledBy: string });

How typescript types can improve safety?

It is interesting as it avoids a typescript to javascript compilation.
It works with plain JS too.

How to parse a programming language with typescript: here a small but working example

A tuple: type PersonProps = [string, number]
A variadic tuple: type Foo<T extends unknown[]> = [string, ...T, number];

A variadic tuple with 2 types:

type Bar<
  T extends unknown[],
  U extends unknown[]
> = [...T, string, ...U];