ferdaber

/**
 * Resolves a list of deferred tasks in parallel or in sequence.
 */
 async function resolvePromises<const T extends readonly (() => any)[]>(
    deferreds: T,
    parallel?: boolean
): Promise<{ -readonly [P in keyof T]: T[P] extends () => infer R ? Awaited<R> : unknown }> {
    if (parallel) {
        return Promise.all(deferreds.map(deferred => deferred())) as any;
    } else {

ferdaber

Creating a Crafting Advanced Macro for FFXIV

• For each recipe, find a rotation in https://ffxivteamcraft.com/
• Export the rotation as a crafting macro, note the time length of the macro
• Create the following secondary macro:

For single macro loop:

Note that 71 is the G key, 67 is the C key, and 86 is the V key

/sleep 500
/presskey2 71

ferdaber

export class AbortablePromise<T> extends Promise<T> {
    #aborted = false;

    abort() {
        this.#aborted = true;
    }

    then<TResult1 = T, TResult2 = never>(
        onfulfilled?:
            | ((value: T) => TResult1 | PromiseLike<TResult1>)

ferdaber

Animated Wedge Plotting

ferdaber

import {
  createContext,
  useRef,
  useContext,
  useCallback,
  useLayoutEffect,
  useEffect,
  ReactNode,
  createElement,
} from "react";

ferdaber

interface Array<T> {
    readonly $first: T;
    readonly $last: T;
    readonly $isEmpty: boolean;

    $avg(): number;
    $compact(filterType: 'non-null'): NonNullable<T>[];
    $compact(filterType?: 'truthy'): Exclude<NonNullable<T>, false | 0 | ''>[];
    $splice(start: number, deleteCount?: number): T[];
    $splice(start: number, deleteCount: number, ...items: T[]): T[];

ferdaber

optimization: {
  splitChunks: {
    chunks: 'async',
    minSize: 30000,
    maxSize: 0,
    minChunks: 1,
    maxAsyncRequests: 5,
    maxInitialRequests: 3,
    automaticNameDelimiter: '~',
    name: true,

ferdaber

import produce from 'immer'
import React, { createContext, ReactNode, useContext, useReducer, useRef } from 'react'

import { debugStore } from './debug-store'

export function createStore<TState>(initialState: TState, debugKey: string, displayName: string) {
  type TProducer = {
    (currentState: TState): TState | void
  }
  type TDispatch = {

ferdaber

const prioritizedVals = {
  a: 0,
  b: 1,
  c: 2
}

function sortWithPriority(a, b) {
  // if it's not a prioritized value the sort value is Infinity and falls back to default sorting
  const s1 = prioritizedVals[a] || Infinity
  const s2 = prioritizedVals[b] || Infinity

ferdaber

import { RouteComponentProps } from '@reach/router'
import {
  ComponentType,
  ComponentClass,
  FunctionComponent,
  JSXElementConstructor,
  ComponentProps,
} from 'react'

// method 1