LibJS: Remove our existing Temporal implementation

Our Temporal implementation is woefully out of date. The spec has been
so vastly rewritten that it is unfortunately not practical to update our
implementation in-place. Even just removing Temporal objects that were
removed from the spec, or updating any of the simpler remaining objects,
has proven to be a mess in previous attempts.

So, this removes our Temporal implementation. AOs used by other specs
are left intact.
This commit is contained in:
Timothy Flynn 2024-11-16 12:51:53 -05:00 committed by Tim Flynn
commit f7517c5b8d
Notes: github-actions[bot] 2024-11-21 00:06:58 +00:00
386 changed files with 8 additions and 33007 deletions

View file

@ -1,198 +0,0 @@
describe("correct behavior", () => {
test("length is 1", () => {
expect(Temporal.PlainDateTime.from).toHaveLength(1);
});
test("PlainDate instance argument", () => {
const plainDate = new Temporal.PlainDate(2021, 7, 6);
const plainDateTime = Temporal.PlainDateTime.from(plainDate);
expect(plainDateTime.year).toBe(2021);
expect(plainDateTime.month).toBe(7);
expect(plainDateTime.day).toBe(6);
expect(plainDateTime.hour).toBe(0);
expect(plainDateTime.minute).toBe(0);
expect(plainDateTime.second).toBe(0);
expect(plainDateTime.millisecond).toBe(0);
expect(plainDateTime.microsecond).toBe(0);
expect(plainDateTime.nanosecond).toBe(0);
});
test("PlainDateTime instance argument", () => {
const plainDateTime_ = new Temporal.PlainDateTime(2021, 7, 6, 18, 14, 47);
const plainDateTime = Temporal.PlainDateTime.from(plainDateTime_);
expect(plainDateTime).not.toBe(plainDateTime_);
expect(plainDateTime.year).toBe(2021);
expect(plainDateTime.month).toBe(7);
expect(plainDateTime.day).toBe(6);
expect(plainDateTime.hour).toBe(18);
expect(plainDateTime.minute).toBe(14);
expect(plainDateTime.second).toBe(47);
expect(plainDateTime.millisecond).toBe(0);
expect(plainDateTime.microsecond).toBe(0);
expect(plainDateTime.nanosecond).toBe(0);
});
test("ZonedDateTime instance argument", () => {
const timeZone = new Temporal.TimeZone("UTC");
const zonedDateTime = new Temporal.ZonedDateTime(1625614921000000000n, timeZone);
const plainDateTime = Temporal.PlainDateTime.from(zonedDateTime);
expect(plainDateTime.year).toBe(2021);
expect(plainDateTime.month).toBe(7);
expect(plainDateTime.day).toBe(6);
expect(plainDateTime.hour).toBe(23);
expect(plainDateTime.minute).toBe(42);
expect(plainDateTime.second).toBe(1);
expect(plainDateTime.millisecond).toBe(0);
expect(plainDateTime.microsecond).toBe(0);
expect(plainDateTime.nanosecond).toBe(0);
});
test("fields object argument", () => {
const object = {
year: 2021,
month: 7,
day: 6,
hour: 23,
minute: 42,
second: 1,
millisecond: 0,
microsecond: 0,
nanosecond: 0,
};
const plainDateTime = Temporal.PlainDateTime.from(object);
expect(plainDateTime.year).toBe(2021);
expect(plainDateTime.month).toBe(7);
expect(plainDateTime.day).toBe(6);
expect(plainDateTime.hour).toBe(23);
expect(plainDateTime.minute).toBe(42);
expect(plainDateTime.second).toBe(1);
expect(plainDateTime.millisecond).toBe(0);
expect(plainDateTime.microsecond).toBe(0);
expect(plainDateTime.nanosecond).toBe(0);
});
test("with 'constrain' overflow option", () => {
const object = {
year: 0,
month: 1,
day: 1,
hour: 24,
minute: 60,
second: 60,
millisecond: 1000,
microsecond: 1000,
nanosecond: 1000,
};
const plainDateTime = Temporal.PlainDateTime.from(object, { overflow: "constrain" });
expect(plainDateTime.year).toBe(0);
expect(plainDateTime.month).toBe(1);
expect(plainDateTime.day).toBe(1);
expect(plainDateTime.hour).toBe(23);
expect(plainDateTime.minute).toBe(59);
expect(plainDateTime.second).toBe(59);
expect(plainDateTime.millisecond).toBe(999);
expect(plainDateTime.microsecond).toBe(999);
expect(plainDateTime.nanosecond).toBe(999);
});
test("PlainDateTime string argument", () => {
const plainDateTime = Temporal.PlainDateTime.from("2021-07-06T23:42:01");
expect(plainDateTime.year).toBe(2021);
expect(plainDateTime.month).toBe(7);
expect(plainDateTime.day).toBe(6);
expect(plainDateTime.hour).toBe(23);
expect(plainDateTime.minute).toBe(42);
expect(plainDateTime.second).toBe(1);
expect(plainDateTime.millisecond).toBe(0);
expect(plainDateTime.microsecond).toBe(0);
expect(plainDateTime.nanosecond).toBe(0);
});
});
describe("errors", () => {
test("missing fields", () => {
expect(() => {
Temporal.PlainDateTime.from({});
}).toThrowWithMessage(TypeError, "Required property day is missing or undefined");
expect(() => {
Temporal.PlainDateTime.from({ year: 0, day: 1 });
}).toThrowWithMessage(TypeError, "Required property month is missing or undefined");
expect(() => {
Temporal.PlainDateTime.from({ month: 1, day: 1 });
}).toThrowWithMessage(TypeError, "Required property year is missing or undefined");
});
test("with 'reject' overflow option", () => {
const values = [
[{ year: 1234567, month: 1, day: 1 }, "Invalid plain date"],
[{ year: 0, month: 13, day: 1 }, "Invalid plain date"],
[{ year: 0, month: 1, day: 32 }, "Invalid plain date"],
[{ year: 0, month: 1, day: 1, hour: 24 }, "Invalid plain time"],
[{ year: 0, month: 1, day: 1, hour: 0, minute: 60 }, "Invalid plain time"],
[{ year: 0, month: 1, day: 1, hour: 0, minute: 0, second: 60 }, "Invalid plain time"],
[
{ year: 0, month: 1, day: 1, hour: 0, minute: 0, second: 0, millisecond: 1000 },
"Invalid plain time",
],
[
{
year: 0,
month: 1,
day: 1,
hour: 0,
minute: 0,
second: 0,
millisecond: 0,
microsecond: 1000,
},
"Invalid plain time",
],
[
{
year: 0,
month: 1,
day: 1,
hour: 0,
minute: 0,
second: 0,
millisecond: 0,
microsecond: 0,
nanosecond: 1000,
},
"Invalid plain time",
],
];
for (const [object, error] of values) {
expect(() => {
Temporal.PlainDateTime.from(object, { overflow: "reject" });
}).toThrowWithMessage(RangeError, error);
}
});
});
describe("errors", () => {
test("custom time zone doesn't have a getOffsetNanosecondsFor function", () => {
const zonedDateTime = new Temporal.ZonedDateTime(0n, {});
expect(() => {
Temporal.PlainDateTime.from(zonedDateTime);
}).toThrowWithMessage(TypeError, "getOffsetNanosecondsFor is undefined");
});
test("string must not contain a UTC designator", () => {
expect(() => {
Temporal.PlainDateTime.from("2021-07-06T23:42:01Z");
}).toThrowWithMessage(
RangeError,
"Invalid date time string '2021-07-06T23:42:01Z': must not contain a UTC designator"
);
});
test("extended year must not be negative zero", () => {
expect(() => {
Temporal.PlainDateTime.from("-000000-01-01");
}).toThrowWithMessage(RangeError, "Invalid date time string '-000000-01-01'");
expect(() => {
Temporal.PlainDateTime.from("000000-01-01"); // U+2212
}).toThrowWithMessage(RangeError, "Invalid date time string '000000-01-01'");
});
});