Lucifier129

type PassengerEnName = {
  type: 'PassengerEnName';
  firstname: string;
  middlename?: string;
  lastname: string;
};

type PassengerCnName = {
  type: 'PassengerCnName';
  firstname: string;

Lucifier129

type ResourcesValue<T> = T extends []
  ? never
  : T extends [Resource<infer V>]
  ? [V]
  : T extends [Resource<infer V>, ...infer Rest]
  ? [V, ...ResourcesValue<Rest>]
  : never;

type InitResource = {
  init<T>(

Lucifier129

const log = (message) => {
  return {
    __typename: 'log',
    message,
  };
};

const raise = (message) => {
  return {
    __typename: 'exception',

Lucifier129

function pipe<T, A>(a: T[], a1: ListAction<T, A>): A[];

function pipe<T, A, B>(a: T[], a1: ListAction<T, A>, a2: ListAction<A, B>): B[];

function pipe<T, A, B, C>(
  a: T[],
  a1: ListAction<T, A>,
  a2: ListAction<A, B>,
  a3: ListAction<B, C>
): C[];

Lucifier129

type ParseResult = {
    success: boolean,
    data: any,
    source: string
}

type ParseFailed = {
    suceess: false,
    data: any,
    source: string

Lucifier129

type ToTS<T extends string> =
    T extends 'Int'
    ? number
    : T extends 'String'
    ? string
    : T extends 'Bool'
    ? boolean
    : never

Lucifier129

type GraphQLObject<T extends string> =
    T extends `\ntype ${infer TypeName} {\n${infer Fields}}\n`
    ? {
        name: TypeName,
        fields: {
            [key in keyof GraphQLObjectFields<Fields>]: GraphQLObjectFields<Fields>[key]
        }
    }
    : never

Lucifier129

type NullElement = null | undefined;

type BasicElement = number | boolean | string;

type ArrayElement = Array<VElement>;

type ObjectElement = {
  props: {
    children?: ArrayElement;
  };

Lucifier129

export type Renderable = {
  renderable: true;
};

type RenderableVStack = {
  elems: Renderable[];
} & Renderable;

const VStack = (...elems: Renderable[]): RenderableVStack => {
  return {

Lucifier129

type PickKey<T extends Pick<any, any>> = T extends Pick<any, infer K> ? K : never;

type EmptySelector<T extends object = any> = {
  select: <K extends keyof T>(key: K) => NoneEmptySelector<T, Pick<T, K>>;
  selectAll: () => CompletedSelector<T>;
};

type NoneEmptySelector<T extends object = any, P extends Pick<T, any> = any> = {
  selected: P;
  select: <K extends Exclude<keyof T, PickKey<P>>>(key: K) => NoneEmptySelector<T, P & Pick<T, K>>;