Today I'm sharing a little trick that I like to use to make switch statements cleaner and more type-safe. Happy to hear other ideas!

> DBOS Cloud, a transactional serverless computing platform, made possible by a revolutionary new operating system, DBOS, that implements OS services on top of a distributed database. We’ve used this new architecture to build a novel TypeScript transactional programming environment that enhances applications with automatic statefulness, transactionality, observability, and cyber-resilience. This makes fault-tolerant cloud-native application development much simpler and faster.

Modern utility toolbelt - rapidly evolving, type safe and esm friendly out of the box. No mutations.

Typia is a transformer library supporting:

• Super-fast Runtime Validators
• Enhanced JSON functions
• Protocol Buffer encoder and decoder
• Random data generator

When developing APIs or writing integration solutions, we often fetch data from multiple sources and combine them together. This requires quite a bit of boilerplate even if you use utility libraries like lodash.

This library aims to be provide a simple type-safe utility that makes the task of combining multiple collections simpler using an intuitive association API.

You may find this API to be reminiscent of association APIs found in ORMs. However, collection-joiner is completely agnostic about how these collections are obtained - so you could for example, fetch a list of users from a database, a list of departments from another service, a list of roles from a key value store and merge them into a single hierarchy when constructing a response.

addEventListener accept function references rather than objects with expected methods like handleEvent

setTimeout and setInterval array map, filter, reduce, forEach, etc. promise then, catch, finally

bind awkward

closures

what say v8? hidden classes

fully init objects give me more perf tips

I have googled this and even got to the second page, and there does not seem to be any kind of consensus.

As far as I can tell, it's a bad idea because it creates code you don't see and accepts inputs that you wouldn't want. And yet, many people seem to like them more than, say, const unions due to being easier to refactor in bulk.

So what gives? Is this a case of IT people having very strong opinions on stuff that doesn't matter? Or is there a technical reason for or against it?

Click bait title, but this post goes into depth about using tsconfig.json correctly and across different layers of your project.

Working with the primary TS compiler API is pretty arduous. It is nice to see dedicated community effort towards making this more approachable.

I've looked into these three and they all seem very similar and seem to cover the same use cases. Does anyone have experience with them? I'm having a hard time making a decision or even figuring out the pros and cons of each of them.

i made a type-safe GroupBy function. ```typescript /**

• Groups array of objects by a given key
• @param arr array of objects to group
• @param key must be present on every object, and it's values must be string|number
• @author telepresence
• @license CC-BY-4.0 */ function groupBy(arr: T[], key: keyof T, defaultAcc: Record = {}) { return arr.reduce((acc, val, i) => { const compValue = val[key]; if (typeof compValue !== 'string' && typeof compValue !== 'number') { throw new Error(key ${key.toString()} has values other than string/number. can only group by string/number values); } if (!acc[compValue]) acc[compValue] = [] acc[compValue].push(val); return acc; }, defaultAcc); } ```

• like lodash's groupBy, but by key and not function
  • group an array of objects which all have a key in common into an object with keys matching all the different possible values of your common key
• type-safe, no unknown's no any's
• does not copy arrays ([...array]), uses push
• supports selecting by keys, where the key values are string / number (although you can easily add symbol support)
• shared for free under the CC BY 4.0 license - only attribution is requred (link to this post is fine)
• custom default accumulator support, if you already know the groups beforehand and would rather have an empty array than undefined.

example: ```typescript const data = [{ "name": "jim", "color": "blue", "age": "22" }, { "name": "Sam", "color": "blue", "age": "33" }, { "name": "eddie", "color": "green", "age": "77" }];

groupBy(data, 'color') would result into:ts { "blue": [ { "name": "jim", "color": "blue", "age": "22" }, { "name": "Sam", "color": "blue", "age": "33" } ], "green": [ { "name": "eddie", "color": "green", "age": "77" } ] } ``` TL;DR i've sucessfully wrote something using generics in typescript for the first time, and i think it's pretty epic.

Why I think Typescript is A Good Thing, But mainly a complaint about the number of programming languages. Other than objects (which were not invented), I don't think any of them are a marked improvement on PL/1.

I came up with a trick to iterate over string union types (kind of). I don't know if anyone has discovered this independently, but I think it's too useful not to share.

You can do it with a pattern like this: ```typescript const values = ['foo', 'bar', 'baz'] as const;

type Value = (typeof values)[number]; ```

Let's break down what is going on here. values is a list of strings, however the as const makes it so that Typescript treats it as a tuple of string literals instead of just string[]. When defining Value, we use that tuple type to get the type of what you would get by indexing the tuple with a number. Since that type could be any of the string literals in the tuple, the resulting type is a union of all the literals in the tuple, i.e. 'foo' | 'bar' | 'baz'. This makes it so you can use Value as the union type, and if you ever want to iterate over all the values of the union, you can do that with values. This should allow you to do the one thing that Typescript's crappy enums has over string unions.

You can see this technique in action in the bot library I made.