David Sherret

@dsherret.dev

1480 Followers 80 Following

Software developer. Prev @deno.land. Working on ts-morph, dprint, and more (https://github.com/dsherret)

A dprint.json configuration file with npm specifiers in the plugins array.

Prompt response from pnpm. Fixed and published.

Test reporter output that shows recently completed tests, oldest pending tests, and then failures at the bottom.

Using the `module` global in a cts file with type completions.

Example code snippet that type checks text and bytes imports.

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

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

$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 }$

A graph of the npm resolution with a slider that allows going through each step the npm resolution takes.

Neurosurgical planning software seen in the show Severance.

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

All the same for just module.exports.default

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

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

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

$```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 }; ```$

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;
```

```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?;
```

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

$```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; } ```$

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.

Deno 2.0.6: 89.5ms
Deno 2.1.0: 34.7ms
Bun 1.1.36: 37.2ms
Node 22.11.0: 28.3ms

A commonjs file importing a math.wasm module where an add function is called with incorrect arguments causing a type checking error.

math.ts imports math.wasm, which has an add and subtract function, which calls into math.ts, which have add and subtract exports.

A math.wasm module that's imported via an import statement with two named exports called "add" and "subtract". These are functions that take two numbers, do the operation, and return the result.

An index.js file requiring an add.js with a package.json with an explicit "type": "commonjs".

$Code: ``` import { ts as ts1 } from "./typescript1.js"; import { ts as ts2 } from "./typescript2.js"; for (let i = 1; i <= 3; i++) { setTimeout(() => { console.log(`${(process.memoryUsage().rss / 1024 ** 2).toFixed(2)} MB`); if (i === 3) { console.log(getVersions().join(", ")); } }, i * 20_000); } function getVersions() { const versions = []; if (process.versions.deno) { versions.push(`Deno ${process.versions.deno}`); // upcoming 2.0.3 } if (process.versions.bun) { versions.push(`Bun ${process.versions.bun}`); // 1.1.33 } versions.push(`Typescript ${ts1.version}`); // 5.5.2 versions.push(`Typescript ${ts2.version}`); // 5.6.2 return versions; } ```$

$Rust code: use jsonc_parser::cst::CstRootNode; use jsonc_parser::cst::CstInputValue; use jsonc_parser::errors::ParseError; use jsonc_parser::json; /// Add a plugin url to the dprint config file's plugins array. /// /// ```jsonc /// { /// "plugins": [ /// "https://plugins.dprint.dev/toml-0.6.3.wasm", /// "<new url goes here>" /// ] /// } /// ``` pub fn add_to_plugins_array( file_text: &str, url: &str, ) -> Result<String, ParseError> { let root_node = CstRootNode::parse(file_text, &Default::default())?; let root_obj = root_node.object_value_or_set(); let plugins = root_obj.array_value_or_set("plugins"); plugins.ensure_multiline(); plugins.append(json!(url)); Ok(root_node.to_string()) }$