Add Luau types

src/createUseBinding.lua

@@ -1,5 +1,5 @@
 local function createUseBinding(roact, useValue)
-	return function(defaultValue)
+	return function<T>(defaultValue: T): (any, (newValue: T) -> ())
 		return unpack(useValue({
 			roact.createBinding(defaultValue)
 		}).value)

src/createUseCallback.lua

@@ -1,5 +1,8 @@
+type DependencyList = { unknown }
+type Function<Args..., Rets...> = (Args...) -> Rets...
+
 local function createUseCallback(useMemo)
-	return function(callback, dependencies)
+	return function<Args..., Rets...>(callback: Function<Args..., Rets...>, dependencies: DependencyList?): Function<Args..., Rets...>
 		return useMemo(function()
 			return callback
 		end, dependencies)

src/createUseEffect.lua

@@ -1,5 +1,9 @@
+type Destructor = () -> ()
+type EffectCallback = (() -> Destructor) | (() -> ())
+type DependencyList = { unknown }
+
 local function createUseEffect(component)
-	return function(callback, dependsOn)
+	return function(callback: EffectCallback, dependsOn: DependencyList?)
 		assert(typeof(callback) == "function", "useEffect callback is not a function")
 
 		component.hookCounter += 1

src/createUseMemo.lua

@@ -1,7 +1,10 @@
 local dependenciesDifferent = require(script.Parent.dependenciesDifferent)
 
+type DependencyList = { unknown }
+type Function<Args..., Rets...> = (Args...) -> Rets...
+
 local function createUseMemo(useValue)
-	return function(createValue, dependencies)
+	return function<T...>(createValue: () -> T..., dependencies: DependencyList?): T...
 		local currentValue = useValue(nil)
 
 		local needToRecalculate = dependencies == nil

src/createUseReducer.lua

@@ -1,5 +1,7 @@
+type Reducer<S, A> = (state: S, action: A) -> S
+
 local function createUseReducer(useCallback, useState)
-	return function(reducer, initialState)
+	return function<S, A>(reducer: Reducer<S, A>, initialState: S): (S, (action: A) -> ())
 		local state, setState = useState(initialState)
 		local dispatch = useCallback(function(action)
 			setState(reducer(state, action))

src/createUseState.lua

@@ -11,7 +11,7 @@ end
 local function createUseState(component)
 	local setValues = {}
 
-	return function(defaultValue)
+	return function<T>(defaultValue: T): (T, (newValue: T) -> ())
 		component.hookCounter += 1
 		local hookCount = component.hookCounter
 		local value = component.state[hookCount]

src/init.lua

@@ -36,8 +36,18 @@ local function createHooks(roact, component)
 	}
 end
 
-function Hooks.new(roact)
-	return function(render, options)
+export type Hooks = typeof(createHooks())
+export type HookOptions<Props> = {
+	name: string?,
+	defaultProps: { [string]: any }?,
+	componentType: "Component" | "PureComponent" | nil,
+	validateProps: ((props: Props) -> (boolean, string?))?,
+	[string]: { NO_EXTRA_ARGS: never },
+}
+export type RenderFunction<Props> = (props: Props, hooks: Hooks) -> any
+
+function Hooks.new<Props>(roact)
+	return function(render: RenderFunction<Props>, options: HookOptions<Props>?)
 		assert(typeof(render) == "function", "Hooked components must be functions.")
 
 		if options == nil then