tomhicks

import {Animated} from "react-native"

export function getSpoingyTransform(
  scrollY: Animated.Value,
  headerHeight: number,
) {
  return [
    {
      translateY: scrollY.interpolate({
        inputRange: [-headerHeight, 0, 1],

tomhicks

import * as React from "react"
import {captureScroll, getSpoingyTransform} from "spoingyHelpers"
import {Animated} from "react-native"

const headerHeight = 300

export default () => {

  // use an instance variable if using component classes
  const scrollY = React.useRef(new Animated.Value(0)).current

tomhicks

#include "node-svm.h"
#include "training-worker.h"
#include "prediction-worker.h"
#include "probability-prediction-worker.h"

using v8::FunctionTemplate;
using v8::Object;
using v8::String;
using v8::Array;

tomhicks

const audioCtx = new window.AudioContext();
const oscillator = audioCtx.createOscillator();
oscillator.connect(audioCtx.destination);
oscillator.type = "sine";

let numItems = 0

oscillator.frequency.setValueAtTime(
  1,
  audioCtx.currentTime

tomhicks

// ATTEMPT 1 - everything in one useEffect
React.useEffect(() => {
  if (screenVideoTrack) {
    createScreenShareOffer()
  } else {
    // 🐞 called before share, on mount
    revokeScreenShareOffer()
  }
  
  // 🐞 called even if screen was never shared

tomhicks

type PromiseSequencer<T> = {
  /**
   * Add a promise to the end of the queue. When this promise resolves, you
   * may be notified via onLatest, assuming that no later promise has resolved
   * in the meantime.
   */
  push(promise: Promise<T>): void;

  /**
   * Remove all promises from the queue. Any promises in the queue can still

tomhicks

import {ChakraProvider, useColorMode} from "@chakra-ui/react"
import {Html} from "next/document"
import React from "react"

type ColorMode = "light" | "dark"
export function ChakraThemedHtmlComponent(props: {
  colorMode: ColorMode
  children: React.ReactNode
}) {
  return (

tomhicks

import React from "react"
import {InternalRoutes} from "types/routes"
import Link, {LinkProps} from "next/link"

export function InternalLink({
  routeName,
  routeParams,
  ...linkProps
}: Omit<LinkProps, "href" | "as"> &
  InternalRoutes & {children: React.ReactChild}) {

tomhicks

let mode: "idle" | "dragging" = "idle"
const dragHandler: InteractionHandler = {
  onDragStart(gesture, app) {
    if (intersection(gesture.elementsUnderCursor, app.selectedElements).size) {
      mode = "dragging";
    }
  },

  onPointerMove(gesture) {
    // ignore pointer-moves when we haven't started dragging

tomhicks

/* eslint-disable import/no-unused-modules */

/**

Usage:

// logs out the calls per frame, mean time, etc, under "myFunction"
const myFunction = instrumentPerFrame(function myFunction() {...});

// pass the name as the first parameter to wrap around methods and give them a name.