leontastic

import React from 'react';

export const preventDefault = (
  handler: React.EventHandler<React.SyntheticEvent>,
): React.EventHandler<React.SyntheticEvent> => (event) => {
  event.preventDefault();
  handler(event);
};

leontastic

export type PromiseFromProps<PromiseMap> = Promise<
  {
    [Property in keyof PromiseMap]: Awaited<PromiseMap[Property]>;
  }
>;

export const fromProps = async <T>(object: T): PromiseFromProps<T> => {
  // invert the object so that we get an array of promises resolving to key-value entries
  const promises = Object.entries(object).map(([property, promise]) =>
    Promise.resolve(promise).then((result) => [property, result]),

leontastic

// memoizer that only remembers the most recent input
const memoizeOne = <Arguments extends any[], Output = any>(
  fn: (...args: Arguments) => Output,
  resolver = (...args: Arguments) => args[0],
) => {
  let resolution: any;
  let value: Output;
  return (...args: Arguments) => {
    const newResolution = resolver(...args);
    if (!resolution || resolution !== newResolution) {

leontastic

// ask your user questions on the command line in sequence
import readline from "readline";

let answer: Promise<string>;

const askQuestion = (question: string) =>
  new Promise<string>(resolve => {
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout

leontastic

Setup:

npm i memwatch-next pino

Usage:

require('./memory-leak-profiler')

leontastic

import { EventEmitter } from 'events'
import { assign, assignIn, forEach, set, unset } from 'lodash'

export default class FirebaseReplicator extends EventEmitter {
  static all (replicators) {
    const emitter = new EventEmitter()

    const start = () => {
      return Promise.all(replicators.map((rep) => rep.start()))
    }

leontastic

/*
  Fraction: an ES6 class to preserve decimal precision in rational number arithmetic

  Notes:
  - reliably preserves decimal precision for floats that can be represented in decimal with 16 decimal places or less
  - for decimals with more than 16 decimal places, precision is preserved up to 16 decimal places

  CONSTRUCTOR:
    constructor([a|Number|Fraction]) => [Fraction]: returns a Fraction from a number

leontastic

### STRING CONCATENATION
s destination source1 source2  // +                              - [[ MUTATE ]] concatenate two sources
t destination source1 string   // +                              - [[ MUTATE ]] concatenate a source followed by a specified string

### FIND
/ source1 source2              // /                              - [[ PRINT ]] print number of times source2 appears in source1
% destination source1 source2  // %                              - [[ MUTATE ]] removes occurrences of source2 in source1

### MEMORY MANAGEMENT
f destination                  // default constructor            - [[ CREATE ]] create empty iString (basically, empty string)

leontastic

; factors: Int -> (listof Int)
; (factors a) produces a list of all positive factors of a, including 1 and itself.

(define (factors a)
  (define b (abs a))
  (filter (lambda (n) (= (remainder b n) 0))
          (build-list b (lambda (y) (+ 1 y)))))

leontastic

; remove-duplicates-clone: (listof Any) -> (listof Any)
; (remove-duplicates-clone loa) produces loa without duplicated elements while preserving the order of elements

(define (remove-duplicates-clone loa)
  (foldr (lambda (x y) (cons x (filter (lambda (z) (not (equal? x z))) y))) empty loa))