Lightnews — Scholar-powered news

David Sherret

@dsherret.bsky.social

Type checking text and bytes imports is now working.

Example code snippet that type checks text and bytes imports.

June 25, 2025 at 5:56 PM

David Sherret

@dsherret.bsky.social

Yup.

Importing a module as bytes and text with a dynamic import.

June 20, 2025 at 8:42 PM

David Sherret

@dsherret.bsky.social

Should have importing files as text and bytes ready for Deno 2.4 -- will be unstable because it hasn't been standardized.

Importing a file as text and bytes with an import attribute.

June 20, 2025 at 8:23 PM

David Sherret

@dsherret.bsky.social

It's very untested and probably won't work in many scenarios, but it's a start. Bugs can be reported here: github.com/denoland/rol...

June 4, 2025 at 9:34 PM

David Sherret

@dsherret.bsky.social

Got bundling JSR/Deno code with Rolldown working.

This is using Rolldown's and Deno's crates respecting Deno's lockfile, config discovery, and resolution. Finally Deno's crates have been refactored enough for this to be feasible (~500 LOC). I'll update with more details later.

$Terminal output showing a JSR specifier being bundled to a single file then executed. > ../rolldown/target/debug/rolldown_deno.exe jsr:@david/dax@0.43 Bundle jsr:@david/dax@0.43 Writing: dax.bundle.js Writing: dax.bundle.js.map > deno Deno 2.3.5 exit using ctrl+d, ctrl+c, or close() REPL is running with all permissions allowed. To specify permissions, run `deno repl` with allow flags. > import $ from "./dax.bundle.js" undefined > await $`echo 'Hello there!' && echo 'This is from a bundled copy.'` Hello there! This is from a bundled copy. CommandResult { code: 0 }$

May 31, 2025 at 2:19 AM

David Sherret

@dsherret.bsky.social

I've come across so many bugs caused by using wildcard matches in Rust. Even though it can be verbose, I think it's better to avoid them in most cases so that adding a new enum variant causes compiler errors, forcing you to re-evaluate each match.

March 27, 2025 at 9:50 PM

David Sherret

@dsherret.bsky.social

It was getting difficult to debug Deno's npm resolution so I wrote a tool to help visualize each step it makes.

March 20, 2025 at 7:35 PM

David Sherret

@dsherret.bsky.social

Neat to see software I used to work on and features I helped implement in Severance.

Neurosurgical planning software seen in the show Severance.

February 25, 2025 at 1:37 AM

David Sherret

@dsherret.bsky.social

Beware: npm doesn't show non-npm dependencies in the dependencies tab. Check out this package—npm lists it as having zero dependencies, but if you look at the package.json, it definitely has dependencies.

The @dsherret/outside-npm package having zero dependencies.

The package.json showing two dependencies.

February 7, 2025 at 9:58 PM

David Sherret

@dsherret.bsky.social

Did some work on the url Rust crate the past two days and got it parsing a 400 character URL more than twice as fast (still have a few PRs not merged).

February 7, 2025 at 9:34 PM

David Sherret

@dsherret.bsky.social

When it's only that they're all the same, but when there's __esModule = true then Bun behaves incompatibly with Node.

All the same for just module.exports.default

Bun making the `default` property the default export once there's __esModule = true

February 5, 2025 at 10:11 PM

David Sherret

@dsherret.bsky.social

It's a confusing topic. Just to be clear, Deno used to do that, but decided to align with Node for better Node compatibility. Here's the output of that today.

Deno and Node where "module.exports" is the default export and in Bun where the defualt export is "module.exports.default"

February 5, 2025 at 4:19 PM

David Sherret

@dsherret.bsky.social

I feel like making node resolution "just work" leaves the JS ecosystem in a worse place.

Bun checking the __esModule property to inform the behaviour of a default import. Bun errors, but Node and Deno don't.

February 5, 2025 at 1:28 AM

David Sherret

@dsherret.bsky.social

@kt3k.org thought of a clever way to get a Uint8Array type in TS 5.7 and Uint8Array type in

```ts
export type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
```

January 30, 2025 at 5:46 PM

David Sherret

@dsherret.bsky.social

This seems to work in all 5.x versions with all script targets.

$```ts // @ts-ignore typed arrays are not generic in TS < 5.7 type NewUint8Array<T> = Uint8Array<T>; interface Child { __test_property__: string; } interface Parent extends Uint8Array, Child { } // Uint8Array#reverse() started returning `this` in TS 5.7 type IsNew = ReturnType<Parent["reverse"]> extends Child ? true : false; type LocalUint8Array<T> = IsNew extends true ? NewUint8Array<T> : Uint8Array; export type { LocalUint8Array as Uint8Array }; ```$

January 29, 2025 at 4:41 PM

David Sherret

@dsherret.bsky.social

TypeScript <5.7 on left, TypeScript 5.7 on right. Glad this seems to work lol. Anyone have a better solution for dealing with Uint8Array being generic now?

buffer property on Uint8Array going to ArrayBufferLike in TS 5.6

```ts
type IsAny<T> = 0 extends (1 & T) ? true : false;
// @ts-ignore uint8array is not generic in TS < 5.7
type NewUint8Array<T> = Uint8Array<T>;

type IsOld = IsAny<NewUint8Array<ArrayBuffer>>;
type Uint8Array2<T> =
IsOld extends true
? Uint8Array
: NewUint8Array<T>;

function test(): Uint8Array2<ArrayBuffer> {
return new Uint8Array([]);
}

const buffer = test().buffer;
```

buffer property on Uint8Array being ArrayBuffer in TS 5.7

January 28, 2025 at 5:34 PM

David Sherret

@dsherret.bsky.social

Worked on this slowly over 5 months, but Deno's config discovery and module resolution logic has been extracted out of the CLI and into a re-usable crate (not yet published). Also a few days ago this setup code was hundreds of lines, but now it's only a few.

```rs
use std::rc::Rc;

use deno_resolver::factory::ResolverFactory;
use deno_resolver::factory::WorkspaceFactory;
use sys_traits::impls::RealSys;

let sys = RealSys;
let cwd = sys.env_current_dir()?;
let workspace_factory = Rc::new(WorkspaceFactory::new(sys, cwd, Default::default()));
let resolver_factory = ResolverFactory::new(workspace_factory.clone(), Default::default());
let deno_resolver = resolver_factory.deno_resolver().await?;
```

January 24, 2025 at 2:13 AM

David Sherret

@dsherret.bsky.social

Wasmbuild is getting simpler thanks to Wasm imports.

Shows a diff of code that was previously complex, but now just requires a single import.

January 8, 2025 at 12:20 AM

David Sherret

@dsherret.bsky.social

It's been a few months so let's bring this up again with an example of what other languages do—unawaited async function call detection is standard in other languages, but missing in TypeScript. So many bugs could be prevented if this were built-in and didn't require separate tooling.

$```csharp async Task Example() { SomeAsyncFunction(); // warns, good await Task.FromResult(1); } async Task ExampleFixed() { await SomeAsyncFunction(); await Task.FromResult(1); } async Task ExampleSuppressedWarning() { _ = SomeAsyncFunction(); await Task.FromResult(1); } async Task SomeAsyncFunction() { // ... await Task.CompletedTask; } ```$ $```rust async fn example() { some_async_function(); // warns, good } async fn example_fixed() { some_async_function().await; } async fn some_async_function() { std::future::ready(1).await; } ```$

```ts
export async function example() {
someAsyncFunction(); // please warn/error here
await Promise.resolve();
}

export async function exampleSuppressed() {
void someAsyncFunction(); // proposed suppression
await Promise.resolve();
}

export async function exampleOkFloatable() {
okToBeFloatable(); // ok because api was defined as floatable
await Promise.resolve();
}

export async function someAsyncFunction() {
// ...
await Promise.resolve();
}

// This does not exist atm, but I think there should be a way for APIs
// to define themselves as floatable given the prevalence of promises
// in return types not expected to be awaited in the JS ecosystem
export async function okToBeFloatable(): Floatable<Promise<void>> {
// ..
await Promise.resolve();
}
```

November 29, 2024 at 6:39 PM

David Sherret

@dsherret.bsky.social

Another example of waiting to implement the standard vs an aggressive "it just works"

It default exports the WebAssembly module instead of exporting the module instance's exports. They'll probably have to do a breaking change for their users.

Code showing Wasm imports where a default export in Node and Deno imports the default export of the instance of the module, but in Bun it exports the module leading this code to error.

November 23, 2024 at 2:25 PM

David Sherret

@dsherret.bsky.social

Unfortunately, this regression existed since WebGPU was re-introduced almost a year ago. I've been working on better tooling for tracking the performance of Deno across operating systems, which is how this was caught. It should be much harder for something like this to happen in the future.