zeusdeux

// Either monad using discriminated unions
export type Either<L, R> =
  | { type: "left"; value: L }
  | { type: "right"; value: R };

export function Left<L, R>(a: L): Either<L, R> {
  return {
    type: "left",
    value: a
  };

zeusdeux

/* ES6/ES2015 classes */
class A {
  constructor() {
    this.a = 10
  }
  print() {
    console.log(this.a, this.b)
  }
}

zeusdeux

Flamegraphs for your node processes on OS X

This document will help you generate flamegraphs for your node processes on OS X.

You can read about the various types of flamegraphs and how they are useful
in Brendan Gregg's wonderful write up here.

By the end of this document, you should have a flamegraph for you node app to play with.

zeusdeux

#!/usr/bin/env bash

# enable when debugging
# set -o errexit
# set -o errtrace
# set -o xtrace
# set -o nounset
# set -o pipefail

plsno () {

zeusdeux

import type { Directive } from "vue";

type ClickOutsideHandler = ($event: MouseEvent | TouchEvent) => void;
type ClickOutsideHandlerMap = Map<HTMLElement, ClickOutsideHandler> & {
  initialized?: boolean;
};

const clickOutsideHandlersSymbol: symbol = Symbol.for("v-click-outside-handlers");

// @ts-ignore

zeusdeux

/**
 * Fail jest test run if certain messages are logged to console (e.g., `[vuex warn] unknown getter: ....`)
 * Conditionally (on CI or not) add this file and the file below to `setupFilesAfterEnv` in jest config.
 *
 * Example config:
 * 
 * import type { Config } from "@jest/types"
 * 
 * const config: Config.InitialOptions = {
 *   ...

zeusdeux

export async function timed<T>(
  cb: () => Promise<T>,
  message: string,
  debug = (...args: any[]) => console.warn(...args),
): ReturnType<typeof cb> {
  const start = performance.now();
  const result = await cb();
  const end = performance.now();
  let timeSpent = end - start;

zeusdeux

type MixedObject = {
  someFn(x: number): string
  someProp: symbol
}

// using key remapping that was added in TS 4.1 wherein
// if we return `never` as a value for key in the remapping logic
// the key is dropped from the resulting type
// More: https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#key-remapping-via-as
type Filter<InputType, AllowedValueTypes> = {

zeusdeux

function assert(cond, msg) {
  if (!cond) throw new Error(msg)
}

function doSet(source, pathToSet, newValue) {
  assert(Array.isArray(pathToSet), 'path being set needs to be given as an array of prop names in order of access')
  
  const prop = pathToSet.shift()

  if (typeof prop === 'undefined') {

zeusdeux

function createProxyHandler() {
  const handler = {
    get(target, prop, receiver) {
      console.log('get>', target, prop, receiver)

      if (prop === '_isProxy') {
        return true
      }

      const value = Reflect.get(target, prop, receiver)