nrkn

export type ToSlugFunction<T extends any[]> = (...args: T) => string

export const sharedPromiseCache = <T extends any[], R>(
  fn: (...args: T) => Promise<R>,
  toSlug: ToSlugFunction<T> = (...args: T) => JSON.stringify(args)
): ((...args: T) => Promise<R>) => {
  const cache = new Map<string, Promise<R>>()

  return async (...args: T): Promise<R> => {
    const key = toSlug(...args)

nrkn

// try to prevent cache stampedes
//
// if you don't do this, then when we get a lot of simultaneous requests for the 
// same thing and it's not cached yet, every single request will think it has
// to generate the resource, whereas using this makes it so that the very first 
// one triggers the work, and the others either wait on the same promise, or get
// served the cached version if it's already resolved
//
// the effect of having every request try to generate something is to overload 
// the server and cause weird side effects, like files not being read or written

nrkn

const firstFloor = 0
const maxFloors = 12

const groundDensity = 0.7
const roofDensity = 0.8

export const pixelMapper = ({ r, g, b }) => {
  if (r === 0 && g === 0 && b === 0) return []

  const floor = r / 255

nrkn

/*
  Your function should take a single data argument, which is an object:

  // information about the image currently being sampled
  {
    
    // the color of the pixel
    r: number, g: number, b: number, a: number, 
    
    // the sample location, relative to the source image

nrkn

import Ajv from 'ajv'
import { FromSchema } from 'json-schema-to-ts'

const productSchema = {
  type: 'object',
  properties: {
    id: { type: 'number' },
    name: { type: 'string' },
    quantity: { type: 'number' },
    type: {

nrkn

import {FromSchema} from 'json-schema-to-ts'
import Ajv from 'ajv'

const ajv = new Ajv()

const schema = {
  type: 'object',
  properties: {
    foo: { type: 'integer' },
    bar: { type: 'string' }

nrkn

const intersectObjHash = ( a, b ) => {
  const hash = {}

  for ( let i = 0; i < b.length; i++ ) {
    hash[ b[ i ] ] = true
  }

  return a.filter( el => hash[ el ] )
}

nrkn

const createSequence = (length, cb) => 
  Array.from({length}, ( _v, k ) => cb( k ))

// create array of characters a-z
const alphaLower = createSequence( 
  26, i => String.fromCharCode( i + 97 ) 
)

// create an array of empty arrays
const arr2d = createSequence( 10, () => [] )

nrkn

const add = (memory, dest, src) => {
  memory[dest] += memory[src]
}

const addV = (memory, dest, value) => {
  memory[dest] += value
}

const sub = (memory, dest, src) => {
  memory[dest] -= memory[src]

nrkn

export const objectFilter = ( obj, predicate ) => {
  if ( obj === null || obj === undefined )
    throw Error( 'Cannot convert null or undefined to an object' )

  if ( typeof predicate !== 'function' )
    throw Error( 'Expected predicate to be a function' )

  obj = Object( obj )

  return Object.keys( obj ).reduce(