@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/src/intrinsics/Date.mts

@@ -0,0 +1,243 @@
+import {
+  Value, JSStringValue, ObjectValue, type Arguments, type FunctionCallContext, NumberValue,
+} from '../value.mts';
+import {
+  AbruptCompletion,
+  Q, ValueOfNormalCompletion, X,
+  type ValueEvaluator,
+} from '../completion.mts';
+import type { Mutable } from '../utils/language.mts';
+import { GetUTCEpochNanoseconds, UTC_TemporalEdited } from '../abstract-ops/temporal/addition.mts';
+import { ParseDateTimeUTCOffset, ParseISODateTime } from '../parser/TemporalParser.mts';
+import { bootstrapConstructor } from './bootstrap.mts';
+import { ToDateString, thisTimeValue } from './DatePrototype.mts';
+import {
+  Assert,
+  OrdinaryCreateFromConstructor,
+  ToPrimitive,
+  ToNumber,
+  ToString,
+  MakeDate,
+  MakeDay,
+  MakeTime,
+  TimeClip,
+  F,
+  type OrdinaryObject,
+  type FunctionObject,
+  Realm,
+  R,
+  SystemUTCEpochMilliseconds,
+  ThrowCompletion,
+  EnsureCompletion,
+  NormalCompletion,
+  BalanceISODateTime,
+  CheckISODaysRange,
+  IsValidEpochNanoseconds,
+  MakeFullYear,
+} from '#self';
+
+export interface DateObject extends OrdinaryObject {
+  DateValue: number;
+}
+export function isDateObject(value: Value): value is DateObject {
+  return 'DateValue' in value;
+}
+/** https://tc39.es/ecma262/#sec-date-constructor */
+function* DateConstructor(values: Arguments, { NewTarget }: FunctionCallContext): ValueEvaluator {
+  if (NewTarget === Value.undefined) {
+    return ToDateString(Value(SystemUTCEpochMilliseconds()));
+  }
+  const numberOfArgs = values.length;
+  if (numberOfArgs >= 2) {
+    /** https://tc39.es/ecma262/#sec-date-year-month-date-hours-minutes-seconds-ms */
+    const [year, month, date, hours, minutes, seconds, ms] = values;
+    Assert(numberOfArgs >= 2);
+    const y = Q(yield* ToNumber(year!));
+    const m = Q(yield* ToNumber(month!));
+    let dt;
+    if (date !== undefined) {
+      dt = Q(yield* ToNumber(date));
+    } else {
+      dt = F(1);
+    }
+    let h;
+    if (hours !== undefined) {
+      h = Q(yield* ToNumber(hours));
+    } else {
+      h = F(+0);
+    }
+    let min;
+    if (minutes !== undefined) {
+      min = Q(yield* ToNumber(minutes));
+    } else {
+      min = F(+0);
+    }
+    let s;
+    if (seconds !== undefined) {
+      s = Q(yield* ToNumber(seconds));
+    } else {
+      s = F(+0);
+    }
+    let milli;
+    if (ms !== undefined) {
+      milli = Q(yield* ToNumber(ms));
+    } else {
+      milli = F(+0);
+    }
+    const yr = MakeFullYear(y);
+    const finalDate = MakeDate(MakeDay(yr, R(m), R(dt)), MakeTime(R(h), R(min), R(s), R(milli)));
+    const O = Q(yield* OrdinaryCreateFromConstructor(NewTarget as FunctionObject, '%Date.prototype%', ['DateValue'])) as Mutable<DateObject>;
+    O.DateValue = TimeClip(UTC_TemporalEdited(finalDate));
+    return O;
+  } else if (numberOfArgs === 1) {
+    const [value] = values;
+    /** https://tc39.es/ecma262/#sec-date-value */
+    Assert(numberOfArgs === 1);
+    let tv;
+    if (value instanceof ObjectValue && 'DateValue' in value) {
+      tv = X(thisTimeValue(value));
+    } else {
+      const v = Q(yield* ToPrimitive(value!));
+      if (v instanceof JSStringValue) {
+        // Assert: The next step never returns an abrupt completion because Type(v) is String.
+        tv = parseDate(v);
+      } else {
+        tv = Q(yield* ToNumber(v));
+      }
+    }
+    const O = Q(yield* OrdinaryCreateFromConstructor(NewTarget as FunctionObject, '%Date.prototype%', ['DateValue'])) as Mutable<DateObject>;
+    O.DateValue = TimeClip(R(tv));
+    return O;
+  } else {
+    /** https://tc39.es/ecma262/#sec-date-constructor-date */
+    Assert(numberOfArgs === 0);
+    const O = Q(yield* OrdinaryCreateFromConstructor(NewTarget as FunctionObject, '%Date.prototype%', ['DateValue'])) as Mutable<DateObject>;
+    O.DateValue = SystemUTCEpochMilliseconds();
+    return O;
+  }
+}
+
+/** https://tc39.es/ecma262/#sec-date.now */
+function Date_now() {
+  const now = SystemUTCEpochMilliseconds();
+  return F(now);
+}
+
+/** https://tc39.es/ecma262/#sec-date.parse */
+function* Date_parse([string = Value.undefined]: Arguments): ValueEvaluator<NumberValue> {
+  const str = yield* ToString(string);
+  if (str instanceof AbruptCompletion) {
+    return str;
+  }
+  return parseDate(ValueOfNormalCompletion(str));
+}
+
+/** https://tc39.es/ecma262/#sec-date.utc */
+function* Date_UTC([year = Value.undefined, month, date, hours, minutes, seconds, ms]: Arguments): ValueEvaluator {
+  const y = Q(yield* ToNumber(year));
+  let m;
+  if (month !== undefined) {
+    m = Q(yield* ToNumber(month));
+  } else {
+    m = F(+0);
+  }
+  let dt;
+  if (date !== undefined) {
+    dt = Q(yield* ToNumber(date));
+  } else {
+    dt = F(1);
+  }
+  let h;
+  if (hours !== undefined) {
+    h = Q(yield* ToNumber(hours));
+  } else {
+    h = F(+0);
+  }
+  let min;
+  if (minutes !== undefined) {
+    min = Q(yield* ToNumber(minutes));
+  } else {
+    min = F(+0);
+  }
+  let s;
+  if (seconds !== undefined) {
+    s = Q(yield* ToNumber(seconds));
+  } else {
+    s = F(+0);
+  }
+  let milli;
+  if (ms !== undefined) {
+    milli = Q(yield* ToNumber(ms));
+  } else {
+    milli = F(+0);
+  }
+
+  const yr = MakeFullYear(y);
+  return Value(TimeClip(MakeDate(MakeDay(yr, R(m), R(dt)), MakeTime(R(h), R(min), R(s), R(milli)))));
+}
+
+/** https://tc39.es/ecma262/#sec-date-time-string-format */
+function parseDate(dateTimeString: JSStringValue): NumberValue {
+  const str = dateTimeString.stringValue();
+  const result = EnsureCompletion(ParseISODateTime(str, ['DateTimeString', 'TemporalInstantString', 'TemporalDateTimeString[~Zoned]', 'TemporalDateTimeString[+Zoned]']));
+  if (result instanceof NormalCompletion) {
+    const parsed = result.Value;
+    const OffsetString = parsed.TimeZone.OffsetString;
+    let offsetNanoseconds = 0n;
+    if (OffsetString !== undefined) {
+      offsetNanoseconds = X(ParseDateTimeUTCOffset(OffsetString));
+    }
+    const time = parsed.Time;
+    Assert(time !== 'start-of-day');
+    const balanced = BalanceISODateTime(parsed.Year!, parsed.Month, parsed.Day, time.Hour, time.Minute, time.Second, time.Millisecond, time.Microsecond, time.Nanosecond - offsetNanoseconds);
+    if (CheckISODaysRange(balanced.ISODate) instanceof ThrowCompletion) {
+      return F(NaN);
+    }
+    const epochNanoseconds = GetUTCEpochNanoseconds(balanced);
+    if (!IsValidEpochNanoseconds(epochNanoseconds)) {
+      return F(NaN);
+    }
+    return F(Number(epochNanoseconds / 1000000n));
+  }
+
+  // Match the following format:
+  // Thu Jan 01 1970 00:00:00 GMT+0000
+  // Thu, 01 Jan 1970 00:00:00 GMT
+  const parse = /(?:(?<weekDay>Sun|Mon|Tue|Wed|Thu|Fri|Sat),? )?(?:(?<monthDay>(?<month>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (?<day>\d{1,2}))|(?<dayMonth>(?<day2>\d{1,2}) (?<month2>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)))? ?(?<year>[+-]?\d+)(?: (?<time>(?<hour>\d{1,2}):(?<minute>\d{1,2})(?::(?<second>\d{1,2}))))?(?: (?<timeZone>\w{3}(?:\+\d+)?))?/g;
+  const match = parse.exec(str);
+  if (!match) {
+    return F(NaN);
+  }
+  const groups = match.groups!;
+  const monthStr = groups.month ?? groups.month2 ?? 'Jan';
+  const dayStr = groups.day ?? groups.day2 ?? 1;
+  const month = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'].indexOf(monthStr);
+  const day = Number(dayStr);
+  const year = Number(groups.year);
+  if (Object.is(year, -0)) {
+    return F(NaN);
+  }
+  let hour = 0;
+  let minute = 0;
+  let second = 0;
+  if (groups.time) {
+    hour = Number(groups.hour);
+    minute = Number(groups.minute);
+    if (groups.second) {
+      second = Number(groups.second);
+    }
+  }
+  // const timeZoneStr = groups.timeZone;
+  // TODO: offset currently dropped
+  return F(TimeClip(MakeDate(MakeDay(year, month, day), MakeTime(hour, minute, second, 0))));
+}
+
+export function bootstrapDate(realmRec: Realm) {
+  const cons = bootstrapConstructor(realmRec, DateConstructor, 'Date', 7, realmRec.Intrinsics['%Date.prototype%'], [
+    ['now', Date_now, 0],
+    ['parse', Date_parse, 1],
+    ['UTC', Date_UTC, 7],
+  ]);
+
+  realmRec.Intrinsics['%Date%'] = cons;
+}