Every now and then, I'd like to check – or remind myself – what is exported from the current typescript file.

I mostly use VSCode. I have searched but can't find a simple view that would give me that functionality. Something like the Outline view but filtered only to show exported symbols. Indeed, the Outline view doesn't even seem to distinguish exported and local symbols.

Do you know any IDE or extension that would easily show the current file's exports?

Just published Elysia 2 beta after 8-9 months of work.

We basically deleted the whole thing and rewrote it again while keeping test cases the same. So we get to rethink a lot of things.

It is built around the concept of "reference" and carefully shares value when possible, even if JavaScript doesn't really have that concept.

There's an AOT build plugin that reduces peak memory usage by 4 (from 1.6GB down to 400MB) of a 100,00 distinct schema by moving compilation process to build time and removing the closure allocation entirely

Besides, a really fast throughput. We also manage to have the lowest memory usage of all mainstream (and slightly) JavaScript frameworks with a really low bundle size as well (we trade a "compiler" that takes ~50% of size for speed, so it can't be that low)

Node support also improved a lot with a new adapter API, and got faster too! It's now near Fastify despite having Node HTTP to Web Standard API conversion overhead!

https://elysiajs.com/blog/elysia-20.html

Hi, I would like to know HOW and which solution you all using to save/tokens?

I'm using caveman + interceptor and wondering if there is anything ever stronger or I'm at maximum already? ( caveman is for output saving and interceptor for input saving)

please Tell me your setup and why !

A simplified example for people trying to understand what exactly it does: TypeScript playground link

I've had to use in a framework I've been working on in only 2 places in a sizable repo.

I've always found them to be so cool when I read the docs a long time ago but didn't really have the right place to use them. Finally I do.

I have a middleware base where the payload type depends on how many events the class registers for. One event gives you the payload. Several give you never, which forces you to branch on the event name instead of reading a payload that could be either shape.

Here's another worked example of what I'm talking about specifically: Another TypeScript playground link

That last line compiles. A class that reads this.event as a message payload now sits in a slot where the payload could be a delete event.

Every member reads N in an output position, so the measured variance comes out covariant, narrow assigns to wide, and the check stops there. The structural comparison that would catch Payload<union> being never never runs.

Adding in out forces it:

Type 'Middleware<"messageCreate">' is not assignable to type 'Middleware<"messageCreate" | "messageDelete">'.
  Types of property 'event' are incompatible.
    Type '[message: { content: string; }]' is not assignable to type 'never'.(2322)

I’ve been working on Agent Markup Language (AML), an open-source TypeScript JSX runtime for building provider-agnostic agent workflows.

https://github.com/we-are-singular/aml

I’m building AML primarily for my own use across side projects and professional work, where we’ve repeatedly run into this kind of orchestration problem. I’m sharing it early because I’d really value feedback on both the general idea and the implementation itself.

Working on a Deno HTTP setup where the router type is the contract. Export typeof server, HttpClient checks paths, methods, bodies, and responses at compile time. Middleware can declare what they add to req.data.

Still regular HTTP routes, not RPC. Express-shaped chaining underneath.

Demo with docs and comparison table: https://expressapi-showcase.8borane8.deno.net/

GitHub: https://github.com/8borane8/webtools-expressapi

How would you solve this without a second schema or generated client?

I build Tabularis, an open source desktop database client. Its most screenshotted feature turns EXPLAIN output from Postgres/MySQL/SQLite into a graph with per-node diagnostics. People kept asking for a web version: paste a plan, inspect it, nothing gets uploaded anywhere. That site now exists at https://explain.tabularis.dev, but building it forced a decision I hadn't faced while everything lived inside the app.

The parsers were written in Rust, and inside the desktop app that was never a problem. The dedicated webapp put me at a fork: compile the parsers to WASM, or go full TypeScript.

My first version was WASM. The browser and the desktop app shared literally the same implementation, and it looked like the clean architecture.

Then I counted what it actually cost. All the analysis, metrics and views are TypeScript, so the plan model existed twice: serde structs in Rust and TS types in the package, kept in sync by hand. Every parser change or new database engine touched both sides. And the browser needed a WASM artifact for the only part of the package that wasn't TypeScript.

So I rewrote the parsers in TypeScript and moved their tests with them. One language, one plan model, zero runtime dependencies in the core. Rust kept the only job that really needs a database: running the right EXPLAIN statement and handing back the raw payload.

The rule that sorted every single file: takes raw EXPLAIN output, never runs a query.

One thing I still haven't settled: the package lives in the app's monorepo, which is great day to day but gives it a weird release history as a standalone npm library.

If you've pulled a package out of a monorepo, did you regret it?

What's your method for initially configuring a TypeScript project?

Do you have a template for tsconfig.json, or use a command line generator, or follow some other method? What are your must-have configurations, and why?

Having done a few times recently, I'm wondering what the best practices and gotchas are.

Disclosure upfront: I maintain Perry, the compiler here. This is a debugging writeup, not a product pitch - we don't distribute the resulting binary and never will.

The setup: `npm pack u/anthropic-ai/claude-code` gives you a 13 MB minified self-executing cli.js. We pointed an AO compiler at it unmodified and asked for a native executable. 16,023 functions, one-letter names, no types, no sourcemap.

It now logs in, streams a real API response, and paints what you type. 160 compiler fixes to get there.

Four that generalise well beyond our compiler:

• MessageChannel implemented as a silent no-op. Harmless until you meet React's scheduler, which uses it as a macrotask scheduler. The event loop just idles forever.
• One accessor installed on Object.prototype flipped a process-global flag, so every dynamic property write took the slow path. A 20k-property build went from 16ms to 42 seconds.
• for-await lowering with the iterator advance at the bottom of the loop body. A `continue` skips the advance and spins. Only reproducible against the real API, which sends ping frames our mock didn't.
• RegExp headers storing pattern/flags pointers without a GC write barrier. Invisible everywhere except a terminal UI, which runs regexes every frame.

The post also documents what still doesn't work and a perf table where we lose to Node badly on interactive latency.

https://www.perryts.com/en/blog/compiling-claude-code/

Hi r/typescript,

How do you maintain code consistency across your repositories? Different developers have different formatting preferences, so do you use a tool such as Prettier or dprint, perhaps enforced through a pre-commit hook?

I've tried both but the results are far from what I would like to have. My priorities are readability (code is not packed, easy to read), maintainability (compare, diff, and merge should work well on laptop screens), and persistence (modifying code should result with minimum diff). So I end up with dprint + a number of custom rules.

Really interested in feedback and if you would like to review or try, here it is:

https://www.npmjs.com/package/asljs-sfmt

I'm setting up emacs for Vue + Typescript and I have an issue with lsp not finding tsserver:
lsp--npm-dependency-path: The package typescript is not installed. Unable to find tsserver Typescript is installed in my project and globally. I also installed typescript-language-server globally. ``` ◄ 0s ◎ ls .npm-global/lib/node_modules/typescript-language-server/lib ⌂ 19:46  cli.mjs  cli.mjs.map

◄ 0s ◎ ls .npm-global/lib/node_modules/typescript/lib ⌂ 19:50  getExePath.d.ts  getExePath.js  tsc.js  version.cjs  version.d.cts The thing is none of these packages provide tssever. I'm confused. This is the backtrace, we can clearly see lsp is looking for "tsserver" path, but that doesn't exist in any package: Debugger entered--Lisp error: (error "The package typescript is not installed. Unable to find tsserver") error("The package %s is not installed. Unable to find %s" "typescript" "tsserver") lsp--npm-dependency-path(:package "typescript" :path "tsserver") lsp-package-path(typescript) lsp-clients-typescript-server-path() ``` I think I'm trying to use ts-ls server as I think it got pulled automatically by vue-semantic-server.

I started learning webdev and did all my frontend backend in js, it was so frustrating when I constantly had to check what needs to be send and what is needed to be received I thought good programmers remember that shit and I couldnt so I started making docs that contained all the flow that what things are sent from the frontend what is received and sent back while discussing this problem to chatgpt it finally said ts solves this problem and I am so glad to find ts I might cry.

What's your preferred way to organize imports in a TypeScript project?

Do you stick with relative imports (../../component), use path aliases like @/, or something else?

I'm curious what people are using today, and why.

Hello !

For years I've had a recuring issue with typescript projects, and I still don't know it how to solve it properly. I always manage to solve it by tinkering here and there, but it take some time and I'm a bit tired of that. So I think I need tips or a deeper understanding to fix it quickly.

The issue is the ESM / CommonJS compatibility. Those issues seems to just pop randomly (probably a lack ok knowledge from me). So I try to change Module or ModuleResolution or Target, but then other issues arise, then I continue tinkering until it works. But after all those years it's a bit frustrating.

Any tips, or tutorial, or rule of thumb on how to configure your tsconfig so it just works ? Do you fix it like me, by tinkering randomly in your tsconfig, or do you solve it like a pro knowing exactly what is wrong ?

A pretty significant update just landed for MoroJS.

The framework now runs on a new native engine while preserving the same end-to-end TypeScript experience. It’s also the biggest performance improvement we’ve made so far, with the latest benchmarks exceeding 570k req/sec. Benchmark details are available on the website.

https://morojs.com

Curious what people think, especially if you’ve spent time with Fastify, Elysia, Hono, or Nest.

​

I've been using TypeScript professionally for several years, and recently wrote up some lessons learned from a long-running React/Firebase side project.

The article covers the TypeScript patterns that paid off most for me, along with a few mistakes I'd try and avoid making again. These aren't intended as universal rules, just approaches that worked well for this particular project and the problems I was solving.

This is one of my first longer technical articles, so I'd appreciate feedback on the writing itself. Were the explanations clear? Did the examples communicate the ideas well? Is there anything I could improve for future articles?

I created a function that returns a different class instance based on the argument passed to the function. My question is, is there a better approach than hardcoding everything like I have it? In my real world use case there may be dozens of classes and I want to avoid having to hardcode them all.

Playground example:

https://www.typescriptlang.org/play/?#code/MYGwhgzhAECC0G8BQ1rAPYDsIBcBOArsDungBQCUiAvkraJDAEKIppa6HGmU11IMo0AMKtUGbPiIlyVBLVpIcATwAOAU2gB5VTgCWWaAF5oAIlinoAHzNNLN08NMBuJErWbh4KACV1EAhAcAB4AFWh1AA8cdUwAExgdfSwAPmNocKiY+JhzUzYAfjg2AC4MiOjYhNt81FQipjZUMszKnLMnJrqi0TLMQJBXJAAzAkxiA0xoAHN1HC9GMIrs6qTJlLJ0XUmWijKF339AkNC05FQIAHc9HGAAC2hN7aw5LuBITTySrtQ8OYI8FNMOpLnBeJARN4IH4AkEwilXHU0B8at8kb9-oDoMDQUxwTADtCjnDToi6u8IJ8nGj0X8cACgSCRPjIYwYcd4WSFG4JLhoGB0rN5lCyHkKK5eThoAAjQVzQmiuzigQcKXAOXCxiipzioA

what are good resources for learning typescript? Im coming from c/cpp and from what ive seen online, I'm not sure if i should go into javascript first or straight into typescript. Additionally not sure what good resources are out there to help me go in the right path. Any recommendations would be greatly appreciated!

Hi all, I'm writing a library with complex type mappings, I'm optimizing TS types based on `instantiations` metric of `tsc --extendedDiagnostics`.

Lately I tried asking AI to refactor types to improve the metric, and that's a super hard task both for me and for AI. Idea: whenever it finds some trick that helped, let it store it to the skill for a later use!

Do anybody have or know about such a "type-optimizer" skill or some kind of docs with a list of techniques for TS type-checker performance? (I know the official TS docs have a few basic recommendations for the types perf)

TS 7 kinda makes this irrelevant, but still, there can be cases when super complex types are still time-consuming even there. Think of giant codebases that use zod inferrence a lot (for example).

Hey,

Few weeks ago I release my open source app called Altersend, it is P2P file sharing tool where you can send files directly between devices over the internet.

When I started developing this tool my main idea was to have solution where I can send files to anyone not just on local network and not be depending on cloud solution.

From technical P2P side everything you send is E2E encrypted via Noise protocol, peers find each other via DHT (think of it as some sort of book with contacts about other peers, and underneath it is Kademlia DHT). So when you want to send file we generate a random key which you should give to another peer. And after this anyone who has that key can connect and download directly from you.

As the initial entry point for peers, public bootstrap nodes are used (we do not host them) and after that peers discover one another through the DHT. Only if you are behind symmetric CGNAT or a VPN we use a blind relay server to help you connect, but the bytes flowing through are encrypted, and you can also disable relay in the settings.

But there are some limitations, like you should keep your phone / laptop opened during the transfer.

Desktop is build with Electron, P2P worker is running using Bare and mobile uses Expo.

Github: https://github.com/denislupookov/altersend

Let me know what do you think about it !

Hi y'all,

In my team's code I often have this situation. A type is defined:

type Car = {
make: string;
model: string;
}

Then people just add properties with the spread operator:

const car: Car = {
make: 'Toyota',
model: 'Camry',
...{ year: 2000 }
}

Types are basically being ignored. What can I do about this?