Gerrit Birkeland Gerrit0

+++ title = "TypeScript - Type Safe Plugins" date = 2024-10-14 +++

A recent question in the TypeScript Discord needs more space than is available there. It happens to be a pretty good question for providing a walkthrough for how I create complex systems, so I am roughly reproducing it here to be able to reference it in the future.

The different subtype error is usually caused by two mistakes:

Providing a default value which might not be specific enough.

function broke<T extends string>(x: T = "error"): T { return x }
//                               ^^^^^^^^^^^^^^
// Type 'string' is not assignable to type 'T'.
//  'string' is assignable to the constraint of type 'T', but
//  'T' could be instantiated with a different subtype of
//  constraint 'string'.

replace.ps1

This is a script to replace placeholders like {name} in a Word document with their values as defined in an Excel spreadsheet.

Usage

Save replace.ps1 below somewhere on your machine.
Create a Word document with your message, for example:

Hello {Name},

There are really three kinds of converters in TypeDoc

File
Modules
Library

Each of these may share individual node converters, but they are fundamentally different. File mode creates a globals map. Modules mode creates a map representing the structure of the package. Library mode creates a map describing the project from one or more entry points.

Furthermore, giving each mode its own converter makes it possible for modes which don't care about which nodes are actually used to create a definition to avoid including those implementation details in their documentation. For instance, a module which is re-exported with export * as ns from './f' in library mode should just be another namespace in the documentation, while modules mode should include it as a module, and create a reference.

	function aggregate<T>(arr: T[], fn: (item: T) => number) {
	return arr.reduce((sum, it) => sum + fn(it), 0);
	}
	function aggregateWithJoiner<T>(arr: T[], fn: (item: T) => number, joiner: string) {
	return arr.reduce((sum, it) => sum + fn(it), 0) + (arr.length - 1) * joiner.length;
	}

	// Used to check if we should split a union into multiple lines.
	export function estimatePrintWidth(type: Type): number {
	return type.visit({

	// @ts-check
	/**
	* typedoc-plugin-not-exported
	* TypeDoc plugin that forces inclusion of non-exported symbols (variables)
	* Originally from https://github.com/TypeStrong/typedoc/issues/1474#issuecomment-766178261
	* https://github.com/tomchen/typedoc-plugin-not-exported
	* CC0
	*/

	const {

	// @ts-check

	const fs = require("fs");
	const http = require("http");
	const esbuild = require("esbuild");
	const { join } = require("path");

	// ===== Configuration =====

	const port = parseInt(process.argv[process.argv.indexOf("--port") + 1]) \|\| 8080;

	import { ok as assert } from 'assert'
	import { readFile, writeFile } from 'fs/promises'

	import { getHighlighter, getTheme } from 'shiki'
	// This is bad... but Shiki doesn't export it from the root.
	import { Highlighter } from 'shiki/dist/highlighter'
	import { TLang } from 'shiki-languages'
	import { TTheme } from 'shiki-themes'

	import { createElement, JSX } from 'preact'

	//@ts-check
	'use strict';

	const fs = require('fs');
	const ts = require('typescript');
	const path = require('path');
	const Module = require('module');

	// These are declared as globals
	const SKIP_MODULES = new Set([

	// ==UserScript==
	// @name Block GIF avatars
	// @namespace https://gerritbirkeland.com/
	// @version 0.1
	// @description try to take over the world!
	// @author You
	// @match https://discord.com/*
	// @grant none
	// ==/UserScript==