NativeScript/nativescript-core/ui/time-picker/time-picker-common.ts

import { TimePicker as TimePickerDefinition } from ".";
import { View, CSSType } from "../core/view";
import { Property } from "../core/properties";

interface Time {
	hour: number;
	minute: number;
}

const dateComparer = (x: Date, y: Date): boolean => x <= y && x >= y;

export function getValidTime(
	picker: TimePickerDefinition,
	hour: number,
	minute: number
): Time {
	if (picker.minuteInterval > 1) {
		let minuteFloor = minute - (minute % picker.minuteInterval);
		minute =
			minuteFloor +
			(minute === minuteFloor + 1 ? picker.minuteInterval : 0);

		if (minute === 60) {
			hour++;
			minute = 0;
		}
	}

	let time = { hour: hour, minute: minute };
	if (!isLessThanMaxTime(picker, hour, minute)) {
		time = { hour: picker.maxHour, minute: picker.maxMinute };
	}

	if (!isGreaterThanMinTime(picker, hour, minute)) {
		time = { hour: picker.minHour, minute: picker.minMinute };
	}

	return time;
}

function isValidTime(picker: TimePickerDefinition): boolean {
	return isGreaterThanMinTime(picker) && isLessThanMaxTime(picker);
}

function isHourValid(value: number): boolean {
	return typeof value === "number" && value >= 0 && value <= 23;
}

function isMinuteValid(value: number): boolean {
	return typeof value === "number" && value >= 0 && value <= 59;
}

function isMinuteIntervalValid(value: number): boolean {
	return (
		typeof value === "number" &&
		value >= 1 &&
		value <= 30 &&
		60 % value === 0
	);
}

function getMinutes(hour: number): number {
	return hour * 60;
}

export function isDefined(value: any): boolean {
	return value !== undefined;
}

function isGreaterThanMinTime(
	picker: TimePickerDefinition,
	hour?: number,
	minute?: number
): boolean {
	if (picker.minHour === undefined || picker.minMinute === undefined) {
		return true;
	}

	return (
		getMinutes(hour !== undefined ? hour : picker.hour) +
			(minute !== undefined ? minute : picker.minute) >=
		getMinutes(picker.minHour) + picker.minMinute
	);
}

function isLessThanMaxTime(
	picker: TimePickerDefinition,
	hour?: number,
	minute?: number
): boolean {
	if (!isDefined(picker.maxHour) || !isDefined(picker.maxMinute)) {
		return true;
	}

	return (
		getMinutes(isDefined(hour) ? hour : picker.hour) +
			(isDefined(minute) ? minute : picker.minute) <=
		getMinutes(picker.maxHour) + picker.maxMinute
	);
}

function toString(value: number | Date): string {
	if (value instanceof Date) {
		return value + "";
	}

	return value < 10 ? `0${value}` : `${value}`;
}

function getMinMaxTimeErrorMessage(picker: TimePickerDefinition): string {
	return `Min time: (${toString(picker.minHour)}:${toString(
		picker.minMinute
	)}), max time: (${toString(picker.maxHour)}:${toString(picker.maxMinute)})`;
}

function getErrorMessage(
	picker: TimePickerDefinition,
	propertyName: string,
	newValue: number | Date
): string {
	return `${propertyName} property value (${toString(newValue)}:${toString(
		picker.minute
	)}) is not valid. ${getMinMaxTimeErrorMessage(picker)}.`;
}

@CSSType("TimePicker")
export abstract class TimePickerBase extends View
	implements TimePickerDefinition {
	public hour: number;
	public minute: number;
	public time: Date;
	public minuteInterval: number;
	public minHour: number;
	public maxHour: number;
	public minMinute: number;
	public maxMinute: number;
}

TimePickerBase.prototype.recycleNativeView = "auto";

export const minHourProperty = new Property<TimePickerBase, number>({
	name: "minHour",
	defaultValue: 0,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isHourValid(newValue) || !isValidTime(picker)) {
			throw new Error(getErrorMessage(picker, "minHour", newValue));
		}
	},
	valueConverter: (v) => parseInt(v),
});
minHourProperty.register(TimePickerBase);

export const maxHourProperty = new Property<TimePickerBase, number>({
	name: "maxHour",
	defaultValue: 23,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isHourValid(newValue) || !isValidTime(picker)) {
			throw new Error(getErrorMessage(picker, "maxHour", newValue));
		}
	},
	valueConverter: (v) => parseInt(v),
});
maxHourProperty.register(TimePickerBase);

export const minMinuteProperty = new Property<TimePickerBase, number>({
	name: "minMinute",
	defaultValue: 0,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isMinuteValid(newValue) || !isValidTime(picker)) {
			throw new Error(getErrorMessage(picker, "minMinute", newValue));
		}
	},
	valueConverter: (v) => parseInt(v),
});
minMinuteProperty.register(TimePickerBase);

export const maxMinuteProperty = new Property<TimePickerBase, number>({
	name: "maxMinute",
	defaultValue: 59,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isMinuteValid(newValue) || !isValidTime(picker)) {
			throw new Error(getErrorMessage(picker, "maxMinute", newValue));
		}
	},
	valueConverter: (v) => parseInt(v),
});
maxMinuteProperty.register(TimePickerBase);

export const minuteIntervalProperty = new Property<TimePickerBase, number>({
	name: "minuteInterval",
	defaultValue: 1,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isMinuteIntervalValid(newValue)) {
			throw new Error(
				getErrorMessage(picker, "minuteInterval", newValue)
			);
		}
	},
	valueConverter: (v) => parseInt(v),
});
minuteIntervalProperty.register(TimePickerBase);

export const minuteProperty = new Property<TimePickerBase, number>({
	name: "minute",
	defaultValue: 0,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isMinuteValid(newValue) || !isValidTime(picker)) {
			throw new Error(getErrorMessage(picker, "minute", newValue));
		}

		picker.time = new Date(0, 0, 0, picker.hour, picker.minute);
	},
	valueConverter: (v) => parseInt(v),
});
minuteProperty.register(TimePickerBase);

export const hourProperty = new Property<TimePickerBase, number>({
	name: "hour",
	defaultValue: 0,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isHourValid(newValue) || !isValidTime(picker)) {
			throw new Error(getErrorMessage(picker, "Hour", newValue));
		}

		picker.time = new Date(0, 0, 0, picker.hour, picker.minute);
	},
	valueConverter: (v) => parseInt(v),
});
hourProperty.register(TimePickerBase);

export const timeProperty = new Property<TimePickerBase, Date>({
	name: "time",
	defaultValue: new Date(),
	equalityComparer: dateComparer,
	valueChanged: (picker, oldValue, newValue) => {
		if (!isValidTime(picker)) {
			throw new Error(getErrorMessage(picker, "time", newValue));
		}

		picker.hour = newValue.getHours();
		picker.minute = newValue.getMinutes();
	},
});
timeProperty.register(TimePickerBase);