itsMapleLeaf

// in RootStore.ts
export class RootStore {
  userStore = new UserStore()
  chatStore = new ChatStore()
  appNavigationStore = new AppNavigationStore()
}

export const RootStoreContext = React.createContext<RootStore>()

export function useRootStore() {

itsMapleLeaf

swagger: "2.0"
info:
  title: "Pixiv Public API"
  description: "Unofficial API specification extracted from Pixiv Android App v4.8.2"
  version: "1.0"
host: public-api.secure.pixiv.net
schemes:
  - https
basePath: /v1
produces:

itsMapleLeaf

function SomeComponent() {
  const { location, error } = useGeolocation()

  useEffect(() => {
    if (error) {
      Analytics.trackEvent("LocationService: ", error.message, error.code)
      handleLocationError(error)
    }
  }, [error])

itsMapleLeaf

type CoGen<R> = {
  next(): IteratorYieldResult<undefined>
  next<T>(value: T): IteratorResult<Promise<T>, R>
}

async function co<R>(genfn: () => CoGen<R>): Promise<R> {
  const it = genfn()
  let result: IteratorResult<unknown, R> = it.next()
  while (true) {
    if (result.done) {

itsMapleLeaf

function Example() {
  const elementRef = useRef<HTMLDivElement>(null) // ref for the element you want to watch
  const isInsideWindow = useWindowIntersection(elementRef)
    
  return <div ref={elementRef}>
    is inside window: {isInWindow}
  </div>
}

itsMapleLeaf

type Thing = {
  a: number
  b: number
  c: string
  d: boolean
}

type Values<O> = O[keyof O]

type KeysWithType<O, T> = Values<{ [K in keyof O]: O[K] extends T ? K : never }>

itsMapleLeaf

import { ReactNode, useEffect, useRef } from "react"
import { createPortal } from "react-dom"

export function Portal({ children }: { children: ReactNode }) {
	const containerRef = useRef<Element>()

	if (!containerRef.current) {
		containerRef.current = document.createElement("react-portal")
		document.body.append(containerRef.current)
	}

itsMapleLeaf

import { useRef } from "react"

const noValue = Symbol()

export default function useInstanceValue<T>(createValue: () => T) {
  const ref = useRef<T | typeof noValue>(noValue)
  if (ref.current === noValue) {
    ref.current = createValue()
  }
  return ref.current

itsMapleLeaf

import { Interpolation } from "@emotion/core"
import { css } from "./styled"

type SizeUnit =
  | 0
  | 1
  | 2
  | 3
  | 4
  | 5

itsMapleLeaf

import { useEffect, useState } from "react"

export type Atom<T> = {
  set(newValue: T): void
  get(): T
  listen(listener: (value: T) => void): () => void
}

export function createAtom<T>(initialValue: T): Atom<T> {
  let currentValue = initialValue