Notices by Axel Rauschmayer (rauschma@fosstodon.org), page 4

1/ #TypeScript & ESM—modern approach that works for me (feedback appreciated!)

## package.json

– Only "exports"—no more "main", "module", "types", "typesVersions"
– Pairings:
– m.d.ts next to m.js
– m.d.mts next to m.mjs

Tree of files:

"exports": {
"./*": "./dist/src/*"
},

Single file:

"exports": {
".": "./dist/src/library.js"
},

## tsconfig.json

"module": "NodeNext",
"moduleResolution": "NodeNext",

## Documentation

– https://nodejs.org/api/packages.html#package-entry-points
– https://www.typescriptlang.org/docs/handbook/modules/reference.html#packagejson-exports

Concatenating strings: template literal vs. concatenating parameters:
b.inlines(`<${tag}${attributes?.toHtml() ?? ''}>`);
b.inlines('<', tag, attributes?.toHtml() ?? '', '>');

Both are verbose. I think I slightly prefer the latter version because the additional space between the pieces helps with reading. It reminds me of the /x flag for regular expressions (see first example): https://xregexp.com/#:~:text=XRegExp%20lets%20you%20write%20regexes%20like%20this

@functionalscript BTW, I can see the appeal of going class-less—it’s more reminiscent of functional programming. Alas, JS misses a few features here—especially algebraic data types and matching.

@functionalscript Interesting!

I find myself starting with object types and often (not always) converting them to classes because I prefer them over factory functions for objects when things get more complicated:
– Methods
– Explicit runtime type

Class-based cloning in #TypeScript is tricky. Ideas?

🟢 Approach 1:
abstract class SuperClass {
abstract clone(): this;
}

Problem: Subclass S can’t invoke its constructor and return the result. TS will complain that `this` could be an instance of a subclass of S; then type is indeed wrong.

🟢 Approach 2: structuredClone
Downsides:
A. Prototypes not preserved (*)
B. Private properties not copied

(B) is fatal for nested class instances.

(*) https://2ality.com/2022/01/structured-clone.html#instances-of-user-defined-classes-become-plain-objects

Making sense of “senseless” JavaScript features:

– 0.1 + 0.2 and the floating point format
– Type coercion
– Automatic semicolon insertion
– Why so many bottom values?
– Increment (++) and decrement (--)

https://www.smashingmagazine.com/2023/12/making-sense-of-senseless-javascript-features/

#JavaScript

1/ W.r.t. optional parameters, JavaScript having both `undefined` and `null` becomes useful because we can distinguish between a parameter being `null` and it being omitted. (Probably not enough of an upside to outweigh the downsides elsewhere.)

In light of this, I’m wondering if we should try to never explicitly use `undefined`—unless we need to skip a positional parameter:

func(1, undefined, 3)

Often better: named parameters (see link below).

https://exploringjs.com/impatient-js/ch_callables.html#parameter-handling

2/ Note that we can create our own special “parameter is missing” values via default parameter values (=we don’t really need a built-in `undefined`):

const MISSING = Symbol('MISSING');
function f(param = MISSING) {
return param === MISSING ? 'MISSING' : param;
}

Using this function:

> f()
'MISSING'
> f(undefined) // also triggers the default value
'MISSING'
> f(null)
null
> f('abc')
'abc'

Leopard: Convert your Scratch projects to JavaScript
https://leopardjs.com/

As explained by @JoshuaKGoldberg, TypeScript doesn’t use semantic versioning (semver): “A new major version of TypeScript (e.g. 5.0.0) is released if the minor version would have exceeded 9 (e.g. 4.10.0).”
https://www.learningtypescript.com/articles/why-typescript-doesnt-follow-strict-semantic-versioning

It’s interesting that people don’t seem to be aware of that and are hesitant about upgrading to a different major version: https://majors.nullvoxpopuli.com/q?minors=on&packages=typescript

#TypeScript

“Infocom’s ingenious code-porting tools for ‘Zork’ and other games have been found”
https://arstechnica.com/gaming/2023/11/infocoms-ingenious-code-porting-tools-for-zork-and-other-games-have-been-found/

Manual by Infocom: "Learning ZIL: everything you always wanted to know about writing interactive fiction but couldn’t find anyone still working here to ask"

Occasionally, I need to collect pieces of text from an HTML page and run code like this in a browser console:

copy(
Array.from(document.querySelectorAll('h2'))
.map(h2 => h2.innerText)
.join('\n')
)

You can also map via the second optional parameter of Array.from(), but I find my version nicer to read (even though it’s less efficient).
https://exploringjs.com/impatient-js/ch_arrays.html#Array.from

#JavaScript #HTML

Once JavaScript has iterator helper methods (*), this code becomes:

copy(
document.querySelectorAll('h2')
.values()
.map(h2 => h2.innerText)
// Alas, there is no .join()
// Roughly equivalent:
.reduce((str, elem) => str+elem+'\n')
)

https://2ality.com/2022/12/iterator-helpers.html

#JavaScript #HTML

I love how each file stored on Google Drive has a unique ID and is not identified by its pathname. Thus, we can rename any component of a pathname without losing the link with the file. We can even move it somewhere else.

It reminds me of Lifestreams where a file system is a chronologically ordered stream of files with unique IDs. Instead of folders, there are tags and queries. That makes creating a file simpler because we don’t have to choose a name and a location.
https://2ality.com/2011/04/information-management-classics.html

@feditips “Toot” seems to be on its way out though(?) At least in the Mastodon UI. Personally, I welcome that, I have always called them “posts”.

#Github does anyone know what the blue dot means?

Update: As mentioned in the replies, the blue dot was alerting me to a new feature (code spaces). Once I clicked on the “learn more” link, it went away.

@feditips I prefer exchanging profile URLs because those are easy to check out via a web browser.