n1ru4l

export const fetchAsBlob = url => fetch(url)
    .then(response => response.blob());

export const convertBlobToBase64 = blob => new Promise((resolve, reject) => {
    const reader = new FileReader;
    reader.onerror = reject;
    reader.onload = () => {
        resolve(reader.result);
    };
    reader.readAsDataURL(blob);

n1ru4l

import Ember from 'ember'

const { Component } = Ember

export default Component.extend({
  // props
  availableItems: undefined,
  selectedItem: undefined,
  onSelectItem: undefined,
})

n1ru4l

import Ember from 'ember'

const { Component } = Ember

export default Component.extend({
  // properties
  options: undefined,
  selectedOption: undefined,
  onChange: undefined,
})

n1ru4l

export const once = (func: Function): Function => {
  let called = false
  let cachedValue = undefined
  return (...args) => {
    if (!called) {
      cachedValue = func(...args)
      called = true
    }
    return cachedValue
  }

n1ru4l

const createEmitter = () => {
  const handlersByEvent = new Map()

  const on = (event, handler) => {
    let handlers = handlersByEvent.get(event)
    if (!handlers) {
      handlers = []
      handlersByEvent.set(event, handlers)
    }
    handlers.push(handler)

n1ru4l

function rmrf (fs, directory, callback) {
  fs.readdir(directory, function (err, list) {
    if (err) return callback(err);
    async.everySeries(list, function (item, callback) {
      var filename = path.join(directory, item);
      var stats = fs.stat(filename, function (err, stat) {
        if (err) return callback(err);
        if (filename === '.' || filename === '..') return callback();
        if (stat.isDirectory()) return rmrf(fs, filename, callback);
        fs.unlink(filename, callback);

n1ru4l

import knex from 'knex'
import knexConfig from 'SUMWHERE'

const prepareDatabase = async () => {
  const migrationTables = [`knex_migrations`, `knex_migrations_lock`]
  const knexInstance = knex(knexConfig)
  const closeConnection = pify(knexInstance.destroy)
  const tableNames = await knexInstance(`pg_tables`)
    .select(`tablename`)
    .where(`schemaname`, `public`)

n1ru4l

const pLimit = require('p-limit');
const os = require('os');
const fs = require('fs');

const fsLimit = pLimit(process.env.UV_THREADPOOL_SIZE || 64);
const processLimit = pLimit(os.cpus().length);

const mkdir = (...args) => fsLimit(() => promisify(fs.mkdir)(...args));
const writeFile = (...args) => fsLimit(() => promisify(fs.writeFile)(...args));
const readFile = (...args) => fsLimit(() => promisify(fs.readFile)(...args));

n1ru4l

import { useEffect, useState } from "react";

const useDebouncedInputValue = (
  initialValue: string,
  debounceDuration: number = 200
): [string, string, (val: string) => void] => {
  const [currentValue, setCurrentValue] = useState(initialValue);
  const [debouncedValue, setDebouncedValue] = useState(currentValue);

  useEffect(() => {

n1ru4l

if (!window.OffscreenCanvas) {
  window.OffscreenCanvas = class OffscreenCanvas {
    constructor(width, height) {
      this.canvas = document.createElement("canvas");
      this.canvas.width = width;
      this.canvas.height = height;

      this.canvas.convertToBlob = () => {
        return new Promise(resolve => {
          this.canvas.toBlob(resolve);