maraisr

 export const map = <T, O>(map: (input: T) => Promise<O> | O) =>
    async function* mapGenerator(asyncIterable: AsyncIterableIterator<T>) {
      for await (const value of asyncIterable) {
        yield map(value);
      }
    };

export const filter = <T, U extends T>(filter: (input: T) => input is U) =>
    async function* filterGenerator(asyncIterable: AsyncIterableIterator<T>) {

maraisr

import type { ElementType } from 'react';
import * as React from 'react';
import { useMemo } from 'react';
import { EntryPointContainer, loadEntryPoint } from 'react-relay/hooks';
import type { EntryPoint } from 'react-relay/lib/relay-experimental/EntryPointTypes';
import { matchPath, useResolvedPath } from 'react-router';
import { resolvePath, useLocation } from 'react-router-dom';

import repositoryEntrypoint from './Repository.entrypoint';

maraisr

const getDeepByPath = <T extends unknown>(obj: T, path: readonly string[]): any => {
	let i = 0;
	let temp = obj;

	for (; i < path.length; ++i) {
		temp = temp[path[i]];
	}
	return temp;
};

maraisr

import { Environment, Network, RecordSource, Store } from 'relay-runtime';
import RelayPublishQueue from 'relay-runtime/lib/store/RelayPublishQueue.js';
import RelayDefaultHandlerProvider from 'relay-runtime/lib/handlers/RelayDefaultHandlerProvider.js';

const network = Network.create(fetchQuery);
const createEnvironment = (records = {}) => {
	const source = new RecordSource(records);
	const store = new Store(source);

maraisr

/* eslint-disable react-hooks/rules-of-hooks */

import { useCallback, useLayoutEffect, useMemo, useState } from 'react';
import { unstable_batchedUpdates } from 'react-dom';

import { useOverdriveContext } from '../components/OverdriveProvider';
import { useTheme } from '../components/ThemeProvider';

export const useMedia = (
	queries: ReadonlyArray<keyof Theme['breakpoints']>,

maraisr

const useLocalQuery = <TQuery extends {response: any; variables: any}>(
  environment: Environment,
  query: any,
  inVariables: TQuery['variables'] = {}
): TQuery['response'] | null => {
  const variables = useDeepEqual(inVariables)
  const [dataRef, setData] = useRefState<SelectorData | null>(null)
  const disposablesRef = useRef<Disposable[]>([])
  useEffect(() => {
    const {getRequest, createOperationDescriptor} = environment.unstable_internal

maraisr

import fetch from 'isomorphic-unfetch';
import React, { createContext, useContext, useMemo } from 'react';
import { ReactRelayContext } from 'react-relay';
import {
	Environment,
	FetchFunction,
	Network,
	RecordSource,
	RequestParameters,
	Store,

maraisr

import { MutableRefObject, useMemo } from 'react';

export const useForkedRef = <T = Element>(...refs: Array<MutableRefObject<T>>): (node: T) => void =>
	useMemo(() => {
		if (refs.every(ref => ref == null)) {
			return null;
		}

		return node => {
			refs.forEach(ref => {

maraisr

Folder Structure

Motivations

• Clear feature ownership
• Module usage predictibility (refactoring, maintainence, you know what's shared, what's not, prevents accidental regressions, avoids huge directories of not-actually-reusable modules, etc)

maraisr

/* tslint:disable */
import fs from 'fs';
import path from 'path';
import ts from 'typescript';

const aliasWhitelist = ['ResponsiveProp'];

const tsconfigPath = path.join(__dirname, '../tsconfig.json');
const componentsFile = path.join(__dirname, '../lib/components/index.ts');