Structural config alternatives

struct-config.ts

type UnionizeArray<D extends Readonly<Array<string>>> = D[number]

const dimensions = ['x', 'y'] as const
const optionalDimensions = ['color', 'radius'] as const

type numerical = 'x' | 'y' | 'radius'

type _ = 'man' | 'opt'
type __ = 'num' | 'nonum'

interface D {
  x: ['num', 'man']
}

type NonEmptyArray<T> = Array<T> & { 0: T }

type RequiredDimensions = UnionizeArray<typeof dimensions>
type OptionalDimensions = UnionizeArray<typeof optionalDimensions>

type Dimensions = RequiredDimensions | OptionalDimensions

type VariableSettings<D extends Record<string, unknown>, K> = K extends numerical
  ? {
      variable: keyof D
      domain: [number, number]
    }
  : {
      variable: keyof D
    }

type OptionalStructureConfig<D extends Record<string, unknown>> = {
  [K in OptionalDimensions]: K extends numerical
    ? Array<VariableSettings<D, K>>
    : Array<VariableSettings<D, K>>
}

export const defaultOptionalStruct = <D>() =>
  optionalDimensions.reduce<OptionalStructureConfig<D>>(
    (acc, k) => ({ ...acc, [k]: [] }),
    {} as OptionalStructureConfig<D>
  )

export type StructureConfig<D extends Record<string, unknown>> = {
  [K in Dimensions]: K extends OptionalDimensions
    ? K extends numerical
      ? Array<VariableSettings<D, K>>
      : Array<VariableSettings<D, K>>
    : K extends numerical
    ? NonEmptyArray<VariableSettings<D, K>>
    : Array<VariableSettings<D, K>>
}

// Alternative approach --------------------------------------

type X = {
  variable: string
  domain: [number, number]
}

type Y = {
  variable: string
  domain: [number, number]
}

type Radius = {
  variable: string
  domain: [number, number]
}

type StructureConfig1 = {
  x: NonEmptyArray<X>
  y: NonEmptyArray<Y>
  radius: Array<Radius>
  // ....
}