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 isPrimitive = obj =>
  obj === null ||
    [ 'string', 'number', 'boolean' ].includes( typeof obj )

const isArrayOfPrimitive = obj =>    
  Array.isArray( obj ) && obj.every( isPrimitive )

const format = arr => 
  `^^^[ ${
    arr.map( val => JSON.stringify( val ) ).join( ', ' )

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

import { Shape } from './shapes.types'
import { area, perimeter } from './shapes.lib'

const shapes: Shape[] = [
  { radius: 4 }, { side: 5 }, { width: 6, height: 7 }
]

const totalArea = shapes.reduce(
  ( sum, shape ) => sum + area( shape ),
  0

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, () => [] )