// const prevRef = useRef<DeepReadonly<GameState>>();

  // const prevRef = useRef<Const<GameState>>();

import { DeepReadonly } from "./lib/util/misc";

import { Const } from "./lib/util/misc";

export const UseGameStateContext = React.createContext<[DeepReadonly<GameState>, UpdaterGeneratorType2<GameState>, () => void]>([] as any);

export const UseGameStateContext = React.createContext<[Const<GameState>, UpdaterGeneratorType2<GameState>, () => void]>([] as any);

export type DeepReadonly<T> = T extends Function ? T : {
  readonly [P in keyof T]: T[P] extends { [k: string]: any } ? DeepReadonly<T[P]> : T[P];

/**
 * A deep readonly type - given an object type, all subobjects and their subobjects are also marked as readonly.
 */
export type Const<T> = T extends Function ? T : {
  readonly [P in keyof T]: T[P] extends { [k: string]: any } ? Const<T[P]> : T[P];

export type Const<T> = DeepReadonly<T>;

// Twice, actually, because of react dev mode double-calling stuff

/**
 * Asserts that a function is not called more than twice. Useful for debugging react lifecycle which may be creating more objects than you realize, impacting performance.
 * @param id identifier
 */

/**
 * Class representing a value which is only computed when used.
 * 
 * Usage: const lazy = new Lazy(() => thingThatReturnsSomething()).
 * Then thingThatReturnsSomething() will only get called on the first time lazy.get() is called.
 * On the second and subsequent times, lazy.get() will return the same object - the factory method is not called again.
 */

/**
 * Multiplies colors (0xFFFFFF === 1). use for applying tints manually.
 * @param color1 A base color
 * @param color2 A tint
 */

// helper method for the recursion

import { assertOnlyCalledOnce, DeepReadonly } from "../lib/util/misc";

import { assertOnlyCalledOnce, Const } from "../lib/util/misc";

  pixiComponentState: DeepReadonly<WindowState>,
  gameState: DeepReadonly<GameState>,

  pixiComponentState: Const<WindowState>,
  gameState: Const<GameState>,

function appSizeFromWindowSize(window?: DeepReadonly<Vector2>): Vector2 {

function appSizeFromWindowSize(window?: Const<Vector2>): Vector2 {