@variocube/app-ui 1.14.5 → 1.16.0

package/src/date-pickers/PlainDateAdapter.ts

@@ -4,136 +4,134 @@ import {parsePlainDate} from "./parse";
 import {PlainAdapterCommon} from "./PlainAdapterCommon";
 
 export class PlainDateAdapter extends PlainAdapterCommon<PlainDate> implements MuiPickersAdapter<PlainDate> {
-    lib = "PlainDateAdapter";
-
-    date(value?: any): PlainDate | null {
-        if (value === null) {
-            return null;
-        }
-        if (value === undefined) {
-            return Now.plainDateISO();
-        }
-
-        if (value instanceof PlainDate) {
-            return value;
-        }
-
-        if (typeof value === "string") {
-            try {
-                return PlainDate.from(value, {overflow: "reject"});
-            }
-            catch (error) {
-                return this.parse(value, this.formats.shortDate);
-            }
-        }
-
-        console.error("Unexpected value", value);
-        return null;
-    }
-
-    toJsDate(value: PlainDate): Date {
-        return new Date(value.year, value.month-1, value.day);
-    }
-
-    parseISO(isString: string): PlainDate {
-        return PlainDate.from(isString);
-    }
-
-    parse(value: string, format: string | DateTimeFormat): PlainDate | null {
-        try {
-            return parsePlainDate(value, format as any as DateTimeFormat);
-        }
-        catch (error) {
-            console.warn("Could not parse", {value, format});
-        }
-        return null;
-    }
-
-    isValid(value: any): boolean {
-        return this.date(value) != null;
-    }
-
-    isEqual(value: any, comparing: any): boolean {
-        const first = this.date(value);
-        const second = this.date(comparing);
-        if (first === second) {
-            return true;
-        }
-        if (!first || !second) {
-            return false;
-        }
-        return first.equals(second);
-    }
-
-    isSameHour(value: PlainDate, comparing: PlainDate): boolean {
-        return true;
-    }
-
-    addSeconds(value: PlainDate, count: number): PlainDate {
-        return value.add({seconds: count});
-    }
-
-    addMinutes(value: PlainDate, count: number): PlainDate {
-        return value.add({minutes: count});
-    }
-
-    addHours(value: PlainDate, count: number): PlainDate {
-        return value.add({hours: count});
-    }
-
-    addDays(value: PlainDate, count: number): PlainDate {
-        return value.add({days: count});
-    }
-
-    addWeeks(value: PlainDate, count: number): PlainDate {
-        return value.add({weeks: count});
-    }
-
-    addMonths(value: PlainDate, count: number): PlainDate {
-        return value.add({months: count});
-    }
-
-    startOfDay(value: PlainDate): PlainDate {
-        return value;
-    }
-
-    endOfDay(value: PlainDate): PlainDate {
-        return value;
-    }
-
-    getHours(value: PlainDate): number {
-        return 0;
-    }
-
-    setHours(value: PlainDate, count: number): PlainDate {
-        return value;
-    }
-
-    getMinutes(value: PlainDate): number {
-        return 0;
-    }
-
-    setMinutes(value: PlainDate, count: number): PlainDate {
-        return value;
-    }
-
-    getSeconds(value: PlainDate): number {
-        return 0;
-    }
-
-    setSeconds(value: PlainDate, count: number): PlainDate {
-        return value;
-    }
-
-    setMonth(value: PlainDate, count: number): PlainDate {
-        return value.with({month: count});
-    }
-
-    setYear(value: PlainDate, count: number): PlainDate {
-        return value.with({year: count});
-    }
-
-    mergeDateAndTime(date: PlainDate, time: PlainDate): PlainDate {
-        return date;
-    }
+	lib = "PlainDateAdapter";
+
+	date(value?: any): PlainDate | null {
+		if (value === null) {
+			return null;
+		}
+		if (value === undefined) {
+			return Now.plainDateISO();
+		}
+
+		if (value instanceof PlainDate) {
+			return value;
+		}
+
+		if (typeof value === "string") {
+			try {
+				return PlainDate.from(value, {overflow: "reject"});
+			} catch (error) {
+				return this.parse(value, this.formats.shortDate);
+			}
+		}
+
+		console.error("Unexpected value", value);
+		return null;
+	}
+
+	toJsDate(value: PlainDate): Date {
+		return new Date(value.year, value.month - 1, value.day);
+	}
+
+	parseISO(isString: string): PlainDate {
+		return PlainDate.from(isString);
+	}
+
+	parse(value: string, format: string | DateTimeFormat): PlainDate | null {
+		try {
+			return parsePlainDate(value, format as any as DateTimeFormat);
+		} catch (error) {
+			console.warn("Could not parse", {value, format});
+		}
+		return null;
+	}
+
+	isValid(value: any): boolean {
+		return this.date(value) != null;
+	}
+
+	isEqual(value: any, comparing: any): boolean {
+		const first = this.date(value);
+		const second = this.date(comparing);
+		if (first === second) {
+			return true;
+		}
+		if (!first || !second) {
+			return false;
+		}
+		return first.equals(second);
+	}
+
+	isSameHour(value: PlainDate, comparing: PlainDate): boolean {
+		return true;
+	}
+
+	addSeconds(value: PlainDate, count: number): PlainDate {
+		return value.add({seconds: count});
+	}
+
+	addMinutes(value: PlainDate, count: number): PlainDate {
+		return value.add({minutes: count});
+	}
+
+	addHours(value: PlainDate, count: number): PlainDate {
+		return value.add({hours: count});
+	}
+
+	addDays(value: PlainDate, count: number): PlainDate {
+		return value.add({days: count});
+	}
+
+	addWeeks(value: PlainDate, count: number): PlainDate {
+		return value.add({weeks: count});
+	}
+
+	addMonths(value: PlainDate, count: number): PlainDate {
+		return value.add({months: count});
+	}
+
+	startOfDay(value: PlainDate): PlainDate {
+		return value;
+	}
+
+	endOfDay(value: PlainDate): PlainDate {
+		return value;
+	}
+
+	getHours(value: PlainDate): number {
+		return 0;
+	}
+
+	setHours(value: PlainDate, count: number): PlainDate {
+		return value;
+	}
+
+	getMinutes(value: PlainDate): number {
+		return 0;
+	}
+
+	setMinutes(value: PlainDate, count: number): PlainDate {
+		return value;
+	}
+
+	getSeconds(value: PlainDate): number {
+		return 0;
+	}
+
+	setSeconds(value: PlainDate, count: number): PlainDate {
+		return value;
+	}
+
+	setMonth(value: PlainDate, count: number): PlainDate {
+		return value.with({month: count});
+	}
+
+	setYear(value: PlainDate, count: number): PlainDate {
+		return value.with({year: count});
+	}
+
+	mergeDateAndTime(date: PlainDate, time: PlainDate): PlainDate {
+		return date;
+	}
 }

package/src/date-pickers/PlainDatePicker.spec.tsx

@@ -1,22 +1,21 @@
+import * as React from "react";
+import {act, create, ReactTestRenderer} from "react-test-renderer";
 import {PlainDate} from "../temporal";
 import {PlainDatePicker} from "./PlainDatePicker";
-import {act, create, ReactTestRenderer} from "react-test-renderer";
-import * as React from "react";
 
 describe("PlainDatePicker", () => {
-
-    test("render", () => {
-        let element: ReactTestRenderer;
-        act(() => {
-            element = create(
-                <PlainDatePicker
-                    locale="de"
-                    value={new PlainDate(2022, 5, 30)}
-                    onChange={() => {}}
-                />);
-        })
-        const {value} = element!.root.findByType("input").props;
-        expect(value).toBe("30.05.2022");
-    });
-
-});
+	test("render", () => {
+		let element: ReactTestRenderer;
+		act(() => {
+			element = create(
+				<PlainDatePicker
+					locale="de"
+					value={new PlainDate(2022, 5, 30)}
+					onChange={() => {}}
+				/>,
+			);
+		});
+		const {value} = element!.root.findByType("input").props;
+		expect(value).toBe("30.05.2022");
+	});
+});

package/src/date-pickers/PlainDatePicker.tsx

@@ -2,15 +2,15 @@ import {DatePicker, LocalizationProvider, PickersDay} from "@mui/x-date-pickers"
 import * as React from "react";
 import {PlainDate} from "../temporal";
 import {PlainDateAdapter} from "./PlainDateAdapter";
-import {useRenderInput, UseRenderInputProps} from "./useRenderInput";
 import {useLocale} from "./useLocale";
+import {useRenderInput, UseRenderInputProps} from "./useRenderInput";
 
 interface PlainDatePickerProps {
-    value: PlainDate | null;
-    onChange: (value: PlainDate | null) => any;
-    label?: string;
-    disabled?: boolean;
-    required?: boolean;
+	value: PlainDate | null;
+	onChange: (value: PlainDate | null) => any;
+	label?: string;
+	disabled?: boolean;
+	required?: boolean;
 
 	disablePast?: boolean;
 	minDate?: PlainDate;
@@ -19,41 +19,40 @@ interface PlainDatePickerProps {
 
 	defaultCalendarMonth?: PlainDate;
 
-    /**
-     * Allows overriding the locale. Only use for testing.
-     */
-    locale?: string;
+	/**
+	 * Allows overriding the locale. Only use for testing.
+	 */
+	locale?: string;
 }
 
 export function PlainDatePicker(props: PlainDatePickerProps & UseRenderInputProps) {
-
-    const {
-        value,
-        onChange,
-        label,
-        disabled,
+	const {
+		value,
+		onChange,
+		label,
+		disabled,
 		disablePast,
 		minDate,
 		maxDate,
 		renderDay,
 		defaultCalendarMonth,
-        locale: suppliedLocale,
-        ...renderInputProps
-    } = props;
+		locale: suppliedLocale,
+		...renderInputProps
+	} = props;
 
-    const locale = useLocale(suppliedLocale);
+	const locale = useLocale(suppliedLocale);
 
-    const renderInput = useRenderInput(renderInputProps);
+	const renderInput = useRenderInput(renderInputProps);
 
-    return (
-        <LocalizationProvider dateAdapter={PlainDateAdapter} adapterLocale={locale}>
-            <DatePicker
-                label={label}
-                value={value}
-                disableMaskedInput
-                onChange={onChange}
-                disabled={disabled}
-                renderInput={renderInput}
+	return (
+		<LocalizationProvider dateAdapter={PlainDateAdapter} adapterLocale={locale}>
+			<DatePicker
+				label={label}
+				value={value}
+				disableMaskedInput
+				onChange={onChange}
+				disabled={disabled}
+				renderInput={renderInput}
 				disablePast={disablePast}
 				defaultCalendarMonth={defaultCalendarMonth}
 				minDate={minDate}
@@ -64,10 +63,8 @@ export function PlainDatePicker(props: PlainDatePickerProps & UseRenderInputProp
 							{renderDay(day, selectedDays)}
 						</PickersDay>
 					)
-					: undefined
-				}
-            />
-        </LocalizationProvider>
-    );
+					: undefined}
+			/>
+		</LocalizationProvider>
+	);
 }
-

package/src/date-pickers/PlainDateTimeAdapter.spec.ts

@@ -2,49 +2,47 @@ import {PlainDateTime} from "../temporal";
 import {PlainDateTimeAdapter} from "./PlainDateTimeAdapter";
 
 describe("PlainDateTimeAdapter", () => {
-
-    const adapter = new PlainDateTimeAdapter({locale: "de"});
-
-    test("isSameDay", () => {
-        expect(adapter.isSameDay(new PlainDateTime(2022, 5, 30), new PlainDateTime(2022, 5, 30))).toBe(true);
-        expect(adapter.isSameDay(new PlainDateTime(2022, 4, 30), new PlainDateTime(2022, 5, 30))).toBe(false);
-    });
-
-    test("isSameYear", () => {
-        expect(adapter.isSameYear(new PlainDateTime(2022, 5, 30), new PlainDateTime(2022, 5, 30))).toBe(true);
-        expect(adapter.isSameYear(new PlainDateTime(2022, 4, 30), new PlainDateTime(2022, 5, 30))).toBe(true);
-        expect(adapter.isSameYear(new PlainDateTime(2020, 4, 30), new PlainDateTime(2022, 5, 30))).toBe(false);
-    });
-
-    test("startOfWeek", () => {
-        const startOfWeek = adapter.startOfWeek(new PlainDateTime(2022, 5, 31));
-        expect(startOfWeek.year).toBe(2022);
-        expect(startOfWeek.month).toBe(5);
-        expect(startOfWeek.day).toBe(30);
-    });
-
-    test("endOfWeek", () => {
-        const startOfWeek = adapter.endOfWeek(new PlainDateTime(2022, 5, 31));
-        expect(startOfWeek.year).toBe(2022);
-        expect(startOfWeek.month).toBe(6);
-        expect(startOfWeek.day).toBe(5);
-    });
-
-    test("getYearRange", () => {
-        const range = adapter.getYearRange(PlainDateTime.from("2020-05-05"), PlainDateTime.from("2025-05-05"));
-        expect(range).toHaveLength(5);
-    });
-
-    test("getWeekArray", () => {
-        const weekArray = adapter.getWeekArray(new PlainDateTime(2022, 5, 30));
-        expect(weekArray).toHaveLength(6);
-        expect(weekArray[0][0].toString()).toBe("2022-04-25T00:00:00"); // monday of first week
-        expect(weekArray[5][6].toString()).toBe("2022-06-05T00:00:00"); // sunday of last week
-    });
-
-    test("getYearRange", () => {
-        const yearRange = adapter.getYearRange(new PlainDateTime(1995, 1, 1), new PlainDateTime(2020, 1, 1));
-        expect(yearRange).toHaveLength(25);
-    })
-
-});
+	const adapter = new PlainDateTimeAdapter({locale: "de"});
+
+	test("isSameDay", () => {
+		expect(adapter.isSameDay(new PlainDateTime(2022, 5, 30), new PlainDateTime(2022, 5, 30))).toBe(true);
+		expect(adapter.isSameDay(new PlainDateTime(2022, 4, 30), new PlainDateTime(2022, 5, 30))).toBe(false);
+	});
+
+	test("isSameYear", () => {
+		expect(adapter.isSameYear(new PlainDateTime(2022, 5, 30), new PlainDateTime(2022, 5, 30))).toBe(true);
+		expect(adapter.isSameYear(new PlainDateTime(2022, 4, 30), new PlainDateTime(2022, 5, 30))).toBe(true);
+		expect(adapter.isSameYear(new PlainDateTime(2020, 4, 30), new PlainDateTime(2022, 5, 30))).toBe(false);
+	});
+
+	test("startOfWeek", () => {
+		const startOfWeek = adapter.startOfWeek(new PlainDateTime(2022, 5, 31));
+		expect(startOfWeek.year).toBe(2022);
+		expect(startOfWeek.month).toBe(5);
+		expect(startOfWeek.day).toBe(30);
+	});
+
+	test("endOfWeek", () => {
+		const startOfWeek = adapter.endOfWeek(new PlainDateTime(2022, 5, 31));
+		expect(startOfWeek.year).toBe(2022);
+		expect(startOfWeek.month).toBe(6);
+		expect(startOfWeek.day).toBe(5);
+	});
+
+	test("getYearRange", () => {
+		const range = adapter.getYearRange(PlainDateTime.from("2020-05-05"), PlainDateTime.from("2025-05-05"));
+		expect(range).toHaveLength(5);
+	});
+
+	test("getWeekArray", () => {
+		const weekArray = adapter.getWeekArray(new PlainDateTime(2022, 5, 30));
+		expect(weekArray).toHaveLength(6);
+		expect(weekArray[0][0].toString()).toBe("2022-04-25T00:00:00"); // monday of first week
+		expect(weekArray[5][6].toString()).toBe("2022-06-05T00:00:00"); // sunday of last week
+	});
+
+	test("getYearRange", () => {
+		const yearRange = adapter.getYearRange(new PlainDateTime(1995, 1, 1), new PlainDateTime(2020, 1, 1));
+		expect(yearRange).toHaveLength(25);
+	});
+});