Usando rxjs para limitar la velocidad de llamadas de retorno

Creo que puedes usar fromEventPattern:

let something;

const src$ = fromEventPattern(
  handler => (something = createSomething({ onSomethingHappened: handler })),
);

src$.pipe(
  throttleTime(300),
  map(args => myCallback(args))
);

Nota: esto asume que myCallback es una operación síncrona.

El primer argumento pasado a fromEventPattern es el addHandler. También puede tener el removeHandler, donde puedes poner tu lógica de limpieza (por ejemplo: liberación de memoria, nulificación de valores, etc).

Para tener una mejor comprensión de qué es handler y por qué se usa ahí, veamos cómo está implementado fromEventPattern:

return new Observable(subscriber => {
  const handler = (...e: T[]) => subscriber.next(e.length === 1 ? e[0] : e);

  let retValue: any;
  try {
    retValue = addHandler(handler);
  } catch (err) {
    subscriber.error(err);
    return undefined;
  }

  if (!isFunction(removeHandler)) {
    return undefined;
  }

  // Esta función devuelta se llamará cuando el observable
  // se desuscriba. Es decir, en la desuscripción manual, en el completo o en el error.
  return () => removeHandler(handler, retValue) ;
});

Fuente.

Como puedes ver, a través de handler, puedes permitir que el observable devuelto emita algo cuando sea el momento.

Solo puedes conectar el operador throttleTime a un flujo fromEvent.

import { fromEvent } from 'rxjs';
import { throttleTime } from 'rxjs/operators';

const mouseMove$ = fromEvent(document, 'mousemove');
mouseMove$.pipe(throttleTime(300)).subscribe(...callback);

No tengo mucha familiaridad con RxJS pero algo como lo siguiente es posible.

Échale un vistazo en StackBlitz: https://stackblitz.com/edit/rxjs-ijzehs.

import { Subject, interval } from 'rxjs';
import { throttle } from 'rxjs/operators';

function myCallback(v) {
  // hacer cosas con el evento, algo computacionalmente intensivo
  console.log("valor recibido", v)
}

const o$ = new Subject()

o$.pipe(throttle(v => interval(300))).subscribe(myCallback)

const algo = crearAlgo({
  enAlgoOcurrio: v => {
    o$.next(v)
  }
})

function crearAlgo({ enAlgoOcurrio }) {
  let i = 0
  setInterval(() => {
    console.log("llamando a enAlgoOcurrio")
    enAlgoOcurrio(i++)
  }, 100)
}

Puedes usar un simple Subject

function myCallback(event) {
  // haz cosas con el evento, algo intensivo computacionalmente
}

// el sujeto presenta todas las emisiones.
const subject = new Subject();
const subscription = subject.pipe( 
  throttle(300), // ahora lo limitamos como querías.
).subscribe(myCallback);

const something = createSomething({
  onSomethingHappened: e => subject.next(e), // usando el sujeto en lugar de una devolución de llamada.
})

// subscription.unsubscribe(); // una vez que no lo necesitamos.