Pass props with conditional typings in VueJS and TypeScript

In your example you pass min and max...

Vue has no way to say: “If range in props is true, then type model [number, number], otherwise number” and also for TS to understand this automatically in the component body.

I would make it universal so that model is always number[]. Something like this:

// App.vue
<script setup lang="ts">
import Comp from './Comp.vue'
import { ref } from 'vue'

const val = ref([5])
const rangeVal = ref([2, 8])
</script>

<template>
  {{val}}
  <Comp v-model="val" />
  {{rangeVal}}
  <Comp v-model="rangeVal" range />
</template>

// Comp.vue
<script setup lang="ts">
import { defineModel } from 'vue'

defineProps<{
  range?: boolean
}>()

const model = defineModel<number[]>({
  default: [],
})
</script>

<template>
  <div v-if="range">
    <input type="number" v-model="model[0]" />
    <input type="number" v-model="model[1]" />
  </div>
  <div v-else>
    <input type="number" v-model="model[0]" />
  </div>
</template>

Vue SFC Playground

<template>
   <!-- First mode without props range -->
  <SliderInput
  
    :min="0"
    :max="10"
     v-model="tempValue1"
  />
   <!-- Second mode with range props -->
  <SliderInput
   
    :min="0"
    :max="10"
    range
     v-model="tempValue2"
  />
</template>
<script setup lang="ts">
  import { ref } from 'vue';
  import SliderInput from './components/SliderInput.vue';

  const tempValue1 = ref<number>(10);
  const tempValue2 = ref<[number, number]>([2, 7]);
</script>

You can solve this with discriminated union props and multiple signatures in defineEmits. This way TypeScript correctly infers the type of modelValue depending on whether range is set or not:

<script setup lang="ts">
import { ref, defineProps, defineEmits } from 'vue'

interface SharedProps {
  min?: number
  max?: number
}

type Props = SharedProps &
  (
    | { range: true; modelValue: [number, number] }
    | { range?: false; modelValue: number }
  )

const props = defineProps<Props>()

const emit = defineEmits<{
  (e: 'update:modelValue', value: number): void
  (e: 'update:modelValue', value: [number, number]): void
}>()

const internalValue = ref(props.modelValue)
const updateValue = (e: Event) => {
  const target = e.target as HTMLInputElement
  const newVal = Number(target.value)
  if (props.range) {
    const newRange: [number, number] = [newVal, newVal + 1]
    internalValue.value = newRange
    emit('update:modelValue', newRange)
  } else {
    internalValue.value = newVal
    emit('update:modelValue', newVal)
  }
}
</script>

<template>
  <div>
    <input
      type="range"
      :min="props.min ?? 0"
      :max="props.max ?? 100"
      :value="Array.isArray(internalValue) ? internalValue[0] : internalValue"
      @input="updateValue"
    />
    <p>Value: {{ internalValue }}</p>
  </div>
</template>

🔹 Result:

• If range is passed, modelValue must be [number, number].

• If range is not passed, modelValue must be number.

• TypeScript enforces this without any casting.