brigand

const create = sessionUser => data => Promise.try(() => transaction(model, async (modelTransaction) => {
  const { CAN_CREATE_ORGANIZATIONS } = getPermissions(sessionUser.permissions);
  const { userId } = sessionUser;
  const { avatar, ...orgData } = data;

  if (!CAN_CREATE_ORGANIZATIONS) {
    throw Unauthorized({ message: 'Sie haben nicht das Recht Organisationen zu erstellen' });
  }

  const insert = params => modelTransaction.query()

brigand

let estate;
let signed;
let watches;

function getImagesAndServePages() {
    estate = require('fs').readdirSync('./public/imgs/estate');
    signed = require('fs').readdirSync('./public/imgs/signed');
    watches = require('fs').readdirSync('./public/imgs/watches');

brigand

const get = (array, currentKey, direction) => {
  const k = currentKey ? currentKey : array[0];
  const delta = direction == 'inc' ? 1 : -1
  const index = array.indexOf(k);
  const nextIndex = (index + delta + array.length) % array.length;
  console.log(array[nextIndex]);
};

brigand

import React, { useState } from 'react';
import styled from '@emotion/styled';
import { Col, Row } from './Flex';

const splitBasis = (percent) => {
  const SCALE = 10000;
  const p = Math.floor(percent * SCALE);
  const shared = { flexShrink: 1 };
  return {
    a: { flexGrow: String(p), ...shared },

brigand

export async function json_to_sheet(...args) {
  const XLSX = await import('xlsx')
  return XLSX.utils.json_to_sheet(...args);
}

brigand

function on(eventTarget, eventType, handler) {
  // Distinct but identical event handler
  const handler2 = (event) => handler(event);
  
  eventTarget.addEventListener(eventType, hander2);
  
  const unsub = () => {
    eventTarget.removeEventListener(eventType, hander2);
  };
  return unsub;

brigand

async function promiseMap(array, mapper, concurrency) {
  const promises = [];
  const results = Array.from({ length: array.length });
 
  const drainOne = async () => {
    const [pj, { index, resolved, rejected }] = await Promise.race(promises.map((p, pi) => p.then((v) => [pi, v])));
    promises.splice(pj, 1);
    
    if (resolved) {
      results[index] = resolved[0];

brigand

function domOn(subject, eventName, handler, options = false) {
  // This function is useless except in the case domOn(x, 'e', f); domOn(x, 'e', f); is run
  // where cleanup can remove the distinct 'inner' function from each call, instead of both 'f' listeners.
  function inner(event) {
    return handler.call(this, event);
  }
  
  subject.addEventListener(eventName, inner, options);
  
  const cleanup = () => subject.removeEventListener(eventName, inner, options);

brigand

import match, { matches, Instance, TypeOf, PropEq, Eq, Check, Index } from '@brigand/unnamed-match-thing';

// Simple matching.
// Note that this is an object literal, so all of these need to
// return something with a toString, and match needs to convert that
// back to the pattern. This implies we need to store Eq('production') in
// module level storage and somehow avoid leaking memory for every pattern ever used.
// Something every toString called here allocates the pattern, and when match() is called
// it can claim all patterns before it (since the toString calls run before match()), removing
// them from the global storage, and then execute the patterns. 

brigand

To install, add this gist as a dependency, and @types/stripe-v3 as a dev dependency.

yarn add --dev @types/stripe-v3
yarn add https://gist.github.com/955eafd92692f4ba54d50d447cef6327.git

Or with npm