typescript | notes | kipras melnikovas

typescript

words:	9 + 2520 = 2529
last update:

typescript. previously #[[(hidden) N-UfQHu88]]
#public
#roam-traverse-graph-settings
{{[[(hidden) j-eCgnBmv]]: {and: [[codemods]] [[typescript]]}}}

Linked Mentions (42 in 38 pages)

September 5th, 2021 (1)

#typescript typescript
- contextual typing:
  - https://stackoverflow.com/a/64653179/9285308
  - alias:
    - "infer backwards"
    - "inferring backwards"
    - outside
    - right to left
    - opposite/reverse to control flow
- {{[[TODO]]}} #[[(hidden) D1lY0CG5e]] holy shit u can generate type-safe `useFetch` react hooks from the express router !!!
  - ofc others would work too, but express is just the one I'm using
  - assuming ofc you have typed out the routes, which u should
  - which makes me realize graphql is not special in this regard; it's only advantaged in this case is that it has a single spec that everyone / every impl follows, and that makes it easier to create code generators that work for everyone, instead of here I could only do express-specific. hm maybe http-specific so all libraries could benefit :o
  - .
- .

September 8th, 2021 (1)

#typescript
- everything I want to do is illegal
  - ```typescript export type SelfWithKeysRecursively<T> = T extends Record<keyof T, any> ? T | T[keyof T] | SelfWithKeysRecursively<T[keyof T]> : never; type DeepObj = { a: { b: { c: { d: 69 } } } } // just fine by using a set-size `DeepObj`. function foo<X extends SelfWithKeysRecursively<DeepObj>>(x: X) {} foo<DeepObj>({ a: { b: { c: { d: 69}}}}) foo<DeepObj["a"]>({ b: { c: { d: 69}}}) foo<DeepObj["a"]["b"]>({ c: { d: 69}}) foo<DeepObj["a"]["b"]["c"]>({ d: 69}) foo<DeepObj["a"]["b"]["c"]["d"]>(69) // error: Type instantiation is excessively deep and possibly infinite. function bar<ArbitraryDeepObj, X extends SelfWithKeysRecursively<ArbitraryDeepObj>>(x: X) {} bar<DeepObj, DeepObj>({ a: { b: { c: { d: 69}}}}) bar<DeepObj, DeepObj["a"]>({ b: { c: { d: 69}}}) bar<DeepObj, DeepObj["a"]["b"]>({ c: { d: 69}}) bar<DeepObj, DeepObj["a"]["b"]["c"]>({ d: 69}) bar<DeepObj, DeepObj["a"]["b"]["c"]["d"]>(69)```
  - ![](https://firebasestorage.googleapis.com/v0/b/firescript-577a2.appspot.com/o/imgs%2Fapp%2Fkipras-g1%2FVXzh9lYLmy.png?alt=media&token=3d34e6be-510c-49e6-9377-870d6fd83705)
  - https://www.typescriptlang.org/play?#[[(hidden) G97ohL3l8]]code/KYDwDg9gTgLgBDAnmYcDKwA2AzA6gSxgAsBpYRAZwCVgBjAVygvwDctEAeAFQD44BeALAAoAJBc4oGMAB2AEwpwataHI4BrchGxwuAGjgBDGYh4jRogPy64AH10BtTYm26AunfRY8hUuWp0jMxsmJxcTlo6XG5mYqIAXHAywGxQANwiIkgocAAiwMBgAPIARgBWAnAA3uaGiTVxJfXmFrTNcRZyiQBsAJwtogC+LcNio6MiAPSTcGX0FPDY+MlwJYhw88sA5kZwFMAwALTMAF6oAAb5haVl5wB0Itj0MrQw+BAycNgQEBwAGpIQNJ5IoMDgCMQyJRlEFWOwOFdiuUeDwABQgRJ-ACU1Qmwm+v0RNzRVSM9VW5La1TgXTgfUGDMGWMePwRBSRZQcACJDFyYqjSU1qVTSbT6QzmfjWUTytzeW5uSU+SS4CKaT1ehKWYT2Tc5XzFQaubRlQL1XTNZKCWzrrKeUalQrjUa5Ka+pKpjNgFAoNBElxkKhlgtjG9DG8PnB8IpQLRgBRguwaeyjPI4JAE-gSqEozIljJCMAHvjnq93p8SoYoBwAIJQEqEKBVxAysoGAFSWQKLzg3xQgIMJhw0K1+uN5utlHozE4qp4yvV1sGSdmurUoWktVizWMyULm0c5e6u3ylUb1Xk7e7kT7pd5Y+c+1Ox0qrcarXCW8Po+2x-yw1Oia-Kiu+e5VgeNw-hy+rPkaQHcq6-LuiIQA

October 4th, 2021 (1)

{{[[DONE]]}} help w/ #[[(hidden) tZLzu9sBI]] issues w/ #typescript
- https://pipedrive.slack.com/archives/C01PSJQ80UW/p1631519260006700
- fuck #[[(hidden) tZLzu9sBI]]
  - https://twitter.com/Rich_Harris/status/1441068317930819589
    - further proves the point
- very useful - #[[(hidden) Z6Wd9qbMT]] (c++ etc) into #[[(hidden) d_KJUbXie]] / #js!! #[[(hidden) jOMmlCP4S]] for #[[(hidden) hzfBb4ct_]]
  - "A simple guide to load C/C++ code into Node.js JavaScript Applications"
  - https://medium.com/jspoint/a-simple-guide-to-load-c-c-code-into-node-js-javascript-applications-3fcccf54fd32
- #[[(hidden) bWZPrHq8o]] fix 😎 😈
  - https://github.com/kiprasmel/using-fs-xattr-with-ts

October 6th, 2021 (1)

{{[[DONE]]}} help [[(hidden) YBB858w4z]] w/ fedocs cli: #typescript,

(hidden) fbJkjZ7H5 (1)

examples of advanced #typescript usage

October 25th, 2021 (2)

currently just wasted a lot of time on #typescript w/ this (as always), so will continue on w/o it atm, because more important features (need to) exist
#typescript HKT - higher kinded types - wanted!
- ```typescript function A<T>(xs: T[]) {} // would make this possible: type Alias = A<string>; // or even this: type Alias<T> = A<T> ```
- currently just wasted a lot of time on #typescript w/ this (as always), so will continue on w/o it atm, because more important features (need to) exist
- [[(hidden) fbJkjZ7H5]]
  - #[[(hidden) DY6wPnICE]] conditional optional parameter
    - ```javascript const f = ( ...props: ({} extends Props ? [] : [Props]) ) => {};```
    - omg the classic array spread, just like in objects to remove a value!!! genius!! did NOT think about it myself lol
    - https://stackoverflow.com/a/52318137/9285308
- [[software i hate]]
  - yarn - love v1, hate that they went into v2 when v2 should've been a completely different project
    - also yarn v1 --ignore-scripts you cannot provide an opposite boolean flag to _not_ ignore scripts, when your config's default is the opposite. ffs

November 4th, 2021 (1)

{{[[TODO]]}} as [[(hidden) tv1zOVzED]] mentioned, #typescript errors will show up when people migrate to cui5, thus we should not spend too much time on this stuff, and instead focus on the things that are both used commonly and are easy to modify.

November 9th, 2021 (1)

{{[[TODO]]}} document #typescript typescript error:
- > An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead.ts(1337)
- > A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type.ts(1169)
- in both cases, you need to:
  - 1. convert from `interface` to `type`
  - 2. convert from `[key: foo]: bar` to `[key in foo]: bar`

November 17th, 2021 (1)

{{[[TODO]]}} definitely need to move to #typescript . it's getting worse w/o it

November 29th, 2021 (2)

ideally #typescript fixes this & we can use the original solution w/o having to have runtime assertions.
WHAT #TIL #[[(hidden) DY6wPnICE]] [[typescript]] is amazing -- you can declare function overloads simply by having an object type!!!
- ```typescript export type Checker<T> = { (item: T): boolean; (item: T, otherItemWhichShouldOnlyBeUsedIfYouNeedToDirectlyCompareThem: T): number; }; ```
- this is big -- if you created regular function overloads, you couldn't even specify the type `T`, because you'd have to cast the value into a type, and then the type `T` would be inlined!!! (i.e., would end up __after__ the quotes, not before, i.e. would infer from argument, instead of allowing the user to specify explicitly!!!)
- the regular function overloads:
  - ```typescript export declare function CheckerAutomatic<T = unknown>( item: T // ): // otherItemWhichShouldOnlyBeUsedIfYouNeedToDirectlyCompareThem: T boolean; export declare function CheckerManual<T = unknown>( A: T, // B: T ): Order | number; export type Check = typeof CheckerManual | typeof CheckerAutomatic;```
- i remembered this might be a thing because i did function overloads for the [[codemods]] transform's (replace-jsx-attribute) configs' `FromToValueMap` and remember the highlight from the editor (well, ts-server) being similar to an object but i didn't realize it up until now 🤯
  - https://github.com/pipedrive/CodeshiftCommunity/blob/d8046f419a5a4e653a4b8c17606c589777b884fc/packages/reusable-transforms/src/replace-jsx-attribute/replace-jsx-attribute.config.ts#[[(hidden) WBl6TSRcS]]115-L116
    - ```typescript export type FromToValueMap = { [key in ValidJsxPropertyValueAsKey]?: | ValidJsxPropertyValueAsValue | FromToValueMapModifierFn /** * otherwise, provide an array of new values. * * if array contains exactly 1 element: * will replace the value automatically; * * else, if array contains >1 element: * will replace the value with the 1st one from the array, and * will add a comment, prefixed with "TODO CODEMOD MANUAL INTERVENTION", to make the user verify themselves. */ | ArrayWithAtLeastOneElement<ValidJsxPropertyValueAsValue>; };```

December 5th, 2021 (1)

{{[[TODO]]}} create issue @ #typescript - allow type guards, without generalizing a readonly value, thus turning it from a specific one into a union (current behavior, want to both guard __and__ have the exact type).
- `allowedCommandAliasesFromGitRebase`

December 9th, 2021 (1)

[[typescript]]
- from a good vid from a while ago:
  - https://youtu.be/nNse0r0aRT8
- now from one of the guys who were in:
  - https://github.com/millsp/ts-toolbelt

December 17th, 2021 (1)

fuck, this doesn't play well w/ [[typescript]].

January 13th, 2022 (1)

{{[[TODO]]}} #[[(hidden) dtTUwyuO_]] / #read the #typescript [[(hidden) Slf8qswwn]] template from [[(hidden) PWFtoHdAm]]
- https://github.com/orta/TypeScript-TSServer-Plugin-Template

January 24th, 2022 (1)

hmmm. [[(hidden) URRQcDCig]] is using [[typescript]] extensively as well (kinda knew it already from e.g. [[(hidden) stBI9LNFL]])
- i then wonder how the #bs w/ [[pipeline operators]] is still going thru -- do they not see the issues / the optimal solution being different?

February 2nd, 2022 (1)

{{[[DONE]]}} help [[(hidden) pEmar0tqN]] w/ [[typescript]]
- > The basic idea is, i have an object like: ```javascript const reg = { a: (p: string) => false, b: (p: number) => 'hello' };``` and im looking to make a function that can do like ```javascript function run( k: keyof reg, p: Parameters<reg[k]> ): ReturnType<reg[k]> { return reg[k](p); }``` and i want all the beautiful typehinting to be automatic and happy
- okay, what we want here is to narrow down the type of the object's value by the object's key, and thus safely use the object's value with an inferred type. & ofc have auto-completions for the correct type when we narrow it down.
- hehe, i don’t think it’s possible yet. https://github.com/microsoft/TypeScript/issues/47648
- > <...>
- i’m excited about the upcoming PRs, even tho some have been there for a while already. https://github.com/microsoft/TypeScript/pull/26349 https://github.com/microsoft/TypeScript/issues/26242 and fwiw, i tried playing w/ it [1] before looking for `typescript infer object value by key` & finding [2] - might be interesting. there’s typeof & keyof that are often used for similar stuff that is possible. [1] https://www.typescriptlang.org/play?#code/FAYw9gdgzgLgBAJwKYHM4F44G87DnAQwC44AKABxNgQEsIUBK[…]Ko9Oc4N73DAguijF9bI-fov2GZ8JmmADUwOPMTkzMCcyA-Mrlgu4gA [2] https://stackoverflow.com/questions/54598322/how-to-make-typescript-infer-the-keys-of-an-object-but-define-type-of-its-value#[[(hidden) GPVT2QZsF]]961[…]0_54598743

February 10th, 2022 (1)

{{[[TODO]]}} #read https://docs.sourcegraph.com/dev/background-information/languages/typescript#typescript-programming-patterns

March 8th, 2022 (1)

great thread on [[(hidden) rWEave84f]] huge codebases to [[typescript]]
- https://twitter.com/alunny/status/1501261149588705282?t=DlRST7ZOFk7OAchLyeI1Jg&s=19
- (hidden) UXxjT50gB #[[(hidden) 7c2C8PgIV]]
  - (hidden) 87gDeXlYN [[(hidden) sJRzxsUIN]] [[(hidden) NfBOcJuy3]]
    - (hidden) sKlAO80f5 [[(hidden) l90lO5xOC]] [[(hidden) e1uk5UrBJ]]
  - (hidden) P2plCpPTc #observation [[(hidden) pRpsZtxIT]]
    - {{[[TODO]]}} (hidden) sPwesqsF8 [[(hidden) oHV0gZ84s]] [[react]]
    - {{[[DONE]]}} (hidden) qnwqyDH1h [[(hidden) boqWOtxuP]] [[(hidden) tYWs3ih5V]] #read
      - (hidden) BtZylR241
        
        (hidden) 6CMClr5nA [[(hidden) CQdTIoSe4]]
        
        (hidden) Q2YZNq9SK [[(hidden) 3vli42X8l]] [[(hidden) iCbE7UjOk]]
        
        (hidden) SIXE5E1x3 [[you'll know it when it's right / this is the way]]
        
        (hidden) KpkQf-trW
      - (hidden) i6c-zo2uf

March 18th, 2022 (1)

(hidden) I3JjiLMdb [[typescript]] #[[(hidden) 7c2C8PgIV]]
- {{[[DONE]]}} (hidden) _3B6kNcT6 [[(hidden) qTwAPyDQY]]
  - {{[[TODO]]}} (hidden) Xa3FjLtb8 [[(hidden) 03-21-2022]]
- (hidden) JCNz1C_FL

March 30th, 2022 (1)

re: why [[typescript]]
- https://pipedrive.slack.com/archives/D02JTAHB9E2/p1648649641596839
- > hehe, typescript because 1. it’s my main language by far, 2. i don’t code in go, 3. i need bindings to git. the libgit2 project provides them, the best version is of course in pure C, but the nodejs version is i think one of the best maintained ones on top of it if not the best, so just makes sense to use it, 4. in the future will need to use github/gitlab/etc APIs, so working w/ http is easy in ts, and both github & gitlab have api client libraries available mostly because of 1., but it all made sense as things went on:D

April 1st, 2022 (1)

{{[[TODO]]}} #read [[typescript]] oh snap thought this was a joke, nvm
- https://twitter.com/mpocock1/status/1509964736275927042?t=wkaIf5d7uZW6j1LfjJkO5g&s=19
  - https://effectivetypescript.com/2020/05/26/iterate-objects/
  - https://twitter.com/AndaristRake/status/1504802241118670848?t=Mcm_ZQyn7UnA3gqO_zScYg&s=19
    - {{[[DONE]]}} #read [[react]] [[(hidden) dn28Y_-7X]] [[fp]]
      - https://twitter.com/devanshj__/status/1497943397956349961?t=IEs7RJ80Xs6JeHCCWfM0sw&s=19
  - {{[[TODO]]}} #read "type challenges"
    - https://twitter.com/didavid61202/status/1509904236355911682?t=3mRGtD5NKoNK2HofRehQoA&s=19
    - https://github.com/type-challenges/type-challenges
  - ```javascript string & {}```
  - https://twitter.com/mpocock1/status/1506660636683653130
    - #TIL `[K in keyof T as K extends A ? B : K extends C ? D : never]` the `as` in keyof!
      
      https://twitter.com/TitianCernicova/status/1461328823711064065/photo/2

April 8th, 2022 (1)

(hidden) qMk4MtiDx #typescript #[[(hidden) 0E1qv_nQd]] #[[(hidden) 7c2C8PgIV]]

April 9th, 2022 (1)

i saw this tweet from [[(hidden) 4ahyMkecn]] on it being easy to refactor a codebase that's 100% in [[typescript]]
- https://twitter.com/AdamRackis/status/1512628657260482563?t=nGojuMgfrU9LIADtM44A9w&s=19
- and then this got me thinking:
  - https://twitter.com/even_uniquer/status/1512653280505118722?t=6YdqJN-nwnviRXO20x0IqQ&s=19
    - > JavaScript peeps rejoice over the smallest things developers in languages like C#[[(hidden) G97ohL3l8]] take for granted and don&#[[(hidden) G97ohL3l8]]39;t even mention as a thing.
      - {{[[TODO]]}} (hidden) u8YsqDcxs #[[(hidden) 7c2C8PgIV]] #[[(hidden) -VnoIOF8r]]
        
        (hidden) d98yuEzHP [[(hidden) bKgs_zIPQ]]
        
        (hidden) FcmjQ13A8
        
        (hidden) 3GsaDcQxP
        
        (hidden) 2Ibz00bUP
        
        (hidden) WOgdZTOaF
        
        (hidden) QKnFTV5eD [[(hidden) lf_Nd8Mic]]
        
        (hidden) dD-b4VImI [[(hidden) oo0Iuzfm7]] #[[(hidden) S-ygYfi0j]] #react #bs
        
        (hidden) APVEvbhMb
        
        (hidden) tTP6EVJJc

April 27th, 2022 (1)

(hidden) l7A39u1nH [[(hidden) tv1zOVzED]] [[typescript]] #[[(hidden) 7c2C8PgIV]]
- (hidden) ULxtK3yNQ #[[(hidden) WBl6TSRcS]]
- {{[[TODO]]}} (hidden) rwPpkpI4w #[[(hidden) BihBadAIv]]
  - (hidden) 9CkBB1ro4
- {{[[TODO]]}} (hidden) x5eJ4UrSa [[(hidden) djNGnEDIa]] #[[(hidden) BihBadAIv]]
  - (hidden) IizN1DPxK [[(hidden) wo8OmNd7H]]
    - (hidden) ZvOT4YKya
  - (hidden) jYGYGHm5W
- (hidden) 533Ie7Hjq

June 6th, 2022 (1)

#typescript
- #TIL
  - you can spread an object A with any properties into object B, even if object B does __not__ accept those properties, as long as A and B have at least 1 common property???
    - this is #bs how do i disallow this? just fixed a bug that would've been caught if this wasn't the case
      - ofc obvious fix is to specify the type for A, before spreading into B, even if B is already typed. but meh !

June 14th, 2022 (1)

though, #typescript support is more meh, which is a shame

June 20th, 2022 (1)

{{[[TODO]]}} maybe just explore the [[typescript]] compiler & see what stuff they do to achieve best perf
- otherwise, instead of all the string mutations & copying, slow loops & array methods etc., go hardcore w/ indices, for loops, minimal functions __w/o__ recursion - use stack instead
- in general, writing now should be way more obvious on how to do correctly

July 20th, 2022 (1)

[[typescript]]
- "union to intersection" (from `A | B` to `A & B`)
  - https://stackoverflow.com/a/50375286/9285308
    - {{[[TODO]]}} #read "distributed conditional types"
      - https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#[[(hidden) G97ohL3l8]]distributive-conditional-types
      - https://github.com/Microsoft/TypeScript/wiki/What&#[[(hidden) G97ohL3l8]]39;s-new-in-TypeScript#[[(hidden) G97ohL3l8]]distributive-conditional-types
        
        {{[[TODO]]}} #read "what's new in typescript"
        
        https://github.com/Microsoft/TypeScript/wiki/What's-new-in-TypeScript
    - {{[[TODO]]}} #read "inference from conditional types"
      - https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#[[(hidden) G97ohL3l8]]type-inference-in-conditional-types

July 25th, 2022 (1)

[[typescript]]
- {{[[TODO]]}} #read https://twitter.com/phry/status/1551626144230817792?t=Axbo3ubFgY7KQhOzknP3vQ&s=19
  - https://artsy.github.io/blog/2018/11/21/conditional-types-in-typescript/
  - https://casualdeveloper.net/post/2020-12-21-advanced-typescript-type-tricks/

July 28th, 2022 (2)

(hidden) 0zvPgg2yO [[(hidden) Slf8qswwn]] [[typescript]] #[[(hidden) 7c2C8PgIV]]
- {{[[TODO]]}} (hidden) 8Alo9Pr0S [[proof-of-concept]] [[vscode]] #[[(hidden) jOMmlCP4S]]
  - (hidden) 9i1TTRdjW
    - {{[[TODO]]}} (hidden) rmmm89CBQ [[jsdoc]]
      - (hidden) QnRLdeQYE
      - (hidden) Qgpk3uQQS
      - (hidden) HvmeVMv8Q
      - (hidden) gFNhS4BSG
      - (hidden) FMJwoZGbl
        
        (hidden) OrzyKyHXW
        
        (hidden) 6EtVYxGF4
        
        (hidden) PR9GtJ4La
        
        (hidden) zE3gOOEMB
        
        (hidden) nvL4t95bs
      - (hidden) _eUBgGez6
    - (hidden) sTxPGiCgh
  - (hidden) U3V91YLad
- (hidden) oe1LILp9F
[[typescript]] inception
- https://twitter.com/ronenamiel/status/1552375586584133633?t=gPyrDse9Oo7oZ5mA9KBdtQ&s=19
  - https://github.com/ronami/HypeScript

typescript (1)

{{[[(hidden) j-eCgnBmv]]: {and: [[codemods]] [[typescript]]}}}

September 26th, 2022 (1)

(hidden) nVqSzpYDE [[typescript]] #[[(hidden) 7c2C8PgIV]]
- (hidden) xuM39H8ht #search
  - (hidden) Lj1FRy5pQ
    - {{[[TODO]]}} (hidden) -QWug-Huh #explore
      - (hidden) f52pttb57
        
        (hidden) pDg0bPfXt
      - (hidden) f9XP0TI68
    - (hidden) n3rkwC28s
    - {{[[TODO]]}} (hidden) v6PV48vqP [[(hidden) 97D0BCTQ-]] #explore
      - (hidden) en5gkW5RN
      - (hidden) hfqcJOrmr
      - (hidden) IEKomaYDg
      - (hidden) fGM-idI2V
    - (hidden) QeniUlH2l
    - (hidden) fPP1J9Znm

September 29th, 2022 (1)

why [[typescript]] won
- https://feeds.resonaterecordings.com/software-unscripted
  - ep 33
    - 25:23

October 1st, 2022 (1)

[[typescript]] 10yo today
- https://twitter.com/ahejlsberg/status/1576301011568033792?t=V67XzASfSd_-ZSz10dIx4g&s=19
  - {{[[TODO]]}} #watch 1st reveal of ts
    - https://youtu.be/3dqZW_DqHIQ

November 8th, 2022 (2)

tried it, & realized that it doesn't make any sense, because there's a ton of useful utilities that the [[typescript]]-specific parser utility [[(hidden) 97D0BCTQ-]] provides
- and we'll definitely want to use more functionality of it, but if i abstract now, it'll be both a lot of work up-front, __and__ harder to experiment in the future
  - so, instead, let's make the project work really well 1st for ts, & only after we need to support multiple langs -- only then
    - [[hindsight bias (in retrospect, it looks simpler than it actually was)]]
      - it's obv that this always applies, you just tend to get [[(hidden) Plv1SNdXC]] sometimes
ofc it's [[typescript]]-specific, so though about abstracting into `lang-provider`
- tried it, & realized that it doesn't make any sense, because there's a ton of useful utilities that the [[typescript]]-specific parser utility [[(hidden) 97D0BCTQ-]] provides
  - and we'll definitely want to use more functionality of it, but if i abstract now, it'll be both a lot of work up-front, __and__ harder to experiment in the future
    - so, instead, let's make the project work really well 1st for ts, & only after we need to support multiple langs -- only then
      - [[hindsight bias (in retrospect, it looks simpler than it actually was)]]
        
        it's obv that this always applies, you just tend to get [[(hidden) Plv1SNdXC]] sometimes

November 10th, 2022 (1)

either with e.g. a [[git]] command, or maybe w/ [[typescript]] [[(hidden) Slf8qswwn]]

January 16th, 2023 (1)

[[typescript]] compilation [[(hidden) uunCioVdj]] improvement
- https://twitter.com/s4chinraja/status/1614675068113817601?s=19

February 28th, 2023 (1)

[[typescript]] niche: simplifying types
- https://twitter.com/ggrandi04/status/1630615559195836417?t=E2_F5BG2mwwK1p508pr08g&s=19
  - cc [[(hidden) GeI3Jlapz]]