Initializing state without known values

descunion.ts

// Descriminated Union
type DataState<T> = 
  | { status: 'loading' }
  | { status: 'error', error: Error }
  | { status: 'success', data: T }

interface User {
  name: string
  age: number
}

const initialState: DataState<User> = { status: 'loading' };

// and then later after state is loaded: { status: 'success', data: state }

generic.ts

// Initializing with empty values with a generic
const EMPTY = Symbol('Empty Value') // initial empty value

export type Initial<T> = {
  [K in keyof T]: Initial<T[K]> | T[K] | typeof EMPTY
}
  
interface User {
  name: string
  age: number
}
 
const initialState: Initial<User> = {
  name: EMPTY,
  age: EMPTY
}

lazyInitFactory.ts

// Lazy Factory
interface UserState {
  name: string;
  age: number;
}

function createInitialState<T>(factory: () => T): () => T {
  let state: T | undefined;
  return () => {
    if (state === undefined) {
      state = factory();
    }
    return state;
  };
}

const getUserState = createInitialState<UserState>(() => {
  // Compute or fetch initial state when first needed
  return { name: "Unknown", age: 0 };
});

nullvalues.ts

// this one can cause type issues "cannot set foo to 'null'" bla bla

interface User {
  name: string | null
  age: number | null
}

const initialState = {
  name: null,
  age: null
}

optionalprops.ts

interface User {
  name?: string
  age?: number
}

const initialState: User = {}

partial.ts

interface User {
  name: string
  age: string
}

const initialState: Partial<User> = {}

specificvalues.ts

// not a fan of this one as the 'default' values can be legit values

interface UserState {
  name: string
  age: number
}

const initialState: UserState = {
  name: '',
  age: -1 
};

typeassertion.ts

interface User {
  name: string
  age: number
}

const initialState = {} as User