dy

// @preact/signals compatible wrapper for signal proposal

import { Signal } from 'signal-polyfill'

const { untrack, Watcher } = Signal.subtle

export const signal = v => wrap(new Signal.State(v))
export const computed = fn => wrap(new Signal.Computed(fn))

export { untrack as untracked }

dy

from https://x.com/_developit/status/1722346883568357856?s=20

1. Untracked function untracked(fn) { computed(fn).peek()}
2. flushSync - read signal value to run all dependent effects
3. Bump function bump (s) {let _ = s.value; s.value = undefined; s.value = _ }

dy

// based on https://github.com/WebReflection/not-so-weak/
const refs = new WeakMap;

const set = value => {
  const ref = new WeakRef(value);
  refs.set(value, ref);
  return ref;
};

dy

Convert C file to wasm, example: https://github.com/jdh8/metallic

clang --target=wasm32 -pipe -O3 -Wall -flto  -I path/to/include -c ./pow.c -o ./pow.o 
llvm-lto ./pow.o -o ./pow.wasm --exported-symbol=pow
wasm2wat -f ./pow.wasm 

Note: can use https://webassembly.github.io/wabt/demo/wasm2wat/ to convert back to text. Note: that for .h files you may want to create wrappers.

dy

Params order

First taken from stack as block, then augmented with inline param.

(func $x (param i32 i32 i32))
...
(i32.const 0)(i32.const 1) (call $x (i32.const 3))

;; converts to

dy

  // web codec API (one day, hopefully)
  const codecConfig = {
    codec: 'mp3',
    sampleRate: 48000,
    numberOfChannels: 2,
    description: new ArrayBuffer
  }
  let chunk = new EncodedAudioChunk({
    type: 'key',

dy

1. () => {} is not the same as () => void.
2. {a?: string | undefined} is tautology.
3. void | undefined | {} | never | null is tautology.
4. Native types Record, Partial etc are a bunch of internal jargon, meaningless from JS view.
5. Interfaces and types are same thing differently named, only creates confusion.
6. unknown vs any: little who cares about the difference.
7. JSX.Element, React.ReactNode, React.ReactFragment is tautology
8. const X = {abc:123} as const

dy

1. If there is //@ts-ignore on the first line, prettier may split it to multiple lines and break ts this way.
2. Prettier expands inline constructs into ugly multiline vertical parts (myriads of examples)
3. Prettier breaks matrices formatting
4. It produces redundant diff logs, making it hard to analyze logic changes

dy

// what if we had simple method on elements, taking in VDOM pieces?
// * it makes sure there's no internal content that messes up rendering
// * it allows simple function as input - something prohibited by preact
// * it enables element existence check

element?.render(({props}) => <div></div>);
element?.render(<div></div>);
element?.render(<Element></Element>);
function Element({props}) { ... }
               

dy

// extension of document fragment, keeps references to children
// based on https://github.com/WebReflection/document-persistent-fragment/blob/master/esm/document-persistent-fragment.js

class Bug extends DocumentFragment {}
const shenanigans = !(new Bug instanceof Bug);

export default class HyperFragment extends DocumentFragment {
  #nodes = []

  // DocumentFragment overrides