Initial @axhxrx/date as JSR package

Author: protiev

.dprint.jsonc

@@ -0,0 +1,14 @@
+{
+  "typescript": {
+    "whileStatement.bracePosition": "nextLine",
+    "arrayExpression.trailingCommas": "onlyMultiLine",
+    "quoteStyle": "preferSingle",
+    "quoteProps": "asNeeded",
+    "bracePosition": "nextLine",
+    "preferHanging": true,
+    "nextControlFlowPosition": "nextLine"
+  },
+  "plugins": [
+    "https://plugins.dprint.dev/typescript-0.88.8.wasm"
+  ]
+}

assertNever.test.ts

@@ -0,0 +1,48 @@
+import { describe, it } from 'https://deno.land/[email protected]/testing/bdd.ts';
+import { assertEquals, assertThrows } from 'jsr:@std/assert';
+import { assertNever } from "./assertNever.ts";
+
+describe('assertNever', () => {
+  it('should exist', () => {
+    assertEquals(typeof assertNever, 'function');
+  });
+
+  it('should work', () => {
+    let state: 'happy' | 'sad' | 'mad';
+    let result = '🤔';
+
+    state = 'happy' as unknown as 'happy' | 'sad' | 'mad';
+    state = 'mad' as unknown as 'happy' | 'sad' | 'mad';
+
+    switch (state) {
+      case 'happy':
+        result = '😀';
+        break;
+      case 'sad':
+        result = '😢';
+        break;
+      case 'mad':
+        result = '😠';
+        break;
+      default:
+        assertNever(state);
+    }
+
+    const errFragment = 'Should never happen: mad';
+
+    const invalidNonexhaustiveSwitch = () => {
+      switch (state) {
+        case 'happy':
+          result = '😀';
+          break;
+        default:
+          // @ts-expect-error Argument of type '"sad" | "mad"' is not assignable to parameter of type 'undefined'.
+          assertNever(state);
+      }
+    };
+
+    assertThrows(invalidNonexhaustiveSwitch, Error, errFragment);
+
+    assertEquals(result, '😠');
+  });
+});

assertNever.ts

@@ -0,0 +1,23 @@
+/**
+ Utility function for [exhaustiveness checking](http://www.typescriptlang.org/docs/handbook/advanced-types.html#exhaustiveness-checkin). Use it to get compile-time errors for non-exhaustive `switch` statements. Example:
+
+ ```ts
+ let state: "happy" | "sad" | "mad";
+ switch(state) {
+   case "happy": return "😀";
+   case "sad":   return "😢";
+   // case "mad" : return "😠";
+   default:
+     assertNever(state);
+       // ERROR:
+       // Argument of type '"mad"' is not assignable
+       // to parameter of type 'never'.ts(2345)
+       //
+       // Uncomment the third case to fix the error by making the switch exhaustive.
+ }
+ ```
+ */
+export const assertNever = (x?: never): never =>
+{
+  throw new Error('Should never happen: ' + x);
+};

dateToFormat.ts

@@ -0,0 +1,49 @@
+import { assertNever } from './assertNever.ts';
+import { dateToIS08601WithTimeZoneOffset } from './dateToIS08601WithTimeZoneOffset.ts';
+
+/**
+ All supported date format strings. This only includes formats we actually use.
+ */
+type DateStringFormat =
+  | 'YYYY-MM-DD'
+  | 'YYYY-MM-DD HH:mm'
+  | 'YYYY-MM-DD HH:mm:ss'
+  | 'YYYYMMDD'; // because sometimes... you know :-/
+
+/**
+ Returns a string expressing a date (the current date, unless otherwise specified) in a particular format.
+ */
+export const dateToFormat = (format: DateStringFormat, date?: Date) =>
+{
+  const fullDateString = dateToIS08601WithTimeZoneOffset(date);
+  const [dateString, timeString] = fullDateString.split('T');
+  const [year, month, day] = dateString.split('-');
+
+  const timeComponents = timeString.split(':');
+  const hour = timeComponents[0];
+  const minute = timeComponents[1];
+  const second = timeComponents[2].substring(0, 2);
+  // const _twoDigitYear = year.slice(2); // NEVER!
+  const twoDigitMonth = month;
+  const twoDigitDay = day;
+  const twoDigitHour = hour;
+  const twoDigitMinute = minute;
+  const twoDigitSecond = second;
+
+  switch (format)
+  {
+    case 'YYYY-MM-DD':
+      return `${year}-${twoDigitMonth}-${twoDigitDay}`;
+    case 'YYYY-MM-DD HH:mm':
+      return `${year}-${twoDigitMonth}-${twoDigitDay} ${twoDigitHour}:${twoDigitMinute}`;
+    case 'YYYY-MM-DD HH:mm:ss':
+      return `${year}-${twoDigitMonth}-${twoDigitDay} ${twoDigitHour}:${twoDigitMinute}:${twoDigitSecond}`;
+    case 'YYYYMMDD':
+      return `${year}${twoDigitMonth}${twoDigitDay}`;
+    default:
+      assertNever(format);
+      throw new Error(
+        `DateUtils.to(): invariant violation: illegal format: ${format}`,
+      );
+  }
+};

dateToIS08601WithTimeZoneOffset.test.ts

@@ -0,0 +1,41 @@
+import { assertEquals } from 'jsr:@std/assert';
+import { dateToIS08601WithTimeZoneOffset } from "./dateToIS08601WithTimeZoneOffset.ts";
+
+const testTimezoneOffset = -540; // JST
+
+
+Deno.test('format a valid date', () =>
+{
+  const date = new Date('2023-10-01T12:00:00Z');
+  const result = dateToIS08601WithTimeZoneOffset(date, testTimezoneOffset);
+  assertEquals(result, '2023-10-01T21:00:00+09:00');
+});
+
+Deno.test('format date with positive non-hour offset', () =>
+{
+  const date = new Date('2023-10-01T12:00:00+05:30');
+  const result = dateToIS08601WithTimeZoneOffset(date, testTimezoneOffset);
+  assertEquals(result, '2023-10-01T15:30:00+09:00');
+});
+
+Deno.test('format date with negative offset', () =>
+{
+  const date = new Date('2023-10-01T12:00:00-04:00');
+  const result = dateToIS08601WithTimeZoneOffset(date, testTimezoneOffset);
+  assertEquals(result, '2023-10-02T01:00:00+09:00');
+});
+
+Deno.test('return ERR_INVALID_DATE for invalid JS Date object', () =>
+{
+  const date = new Date('invalid-date-string');
+  const result = dateToIS08601WithTimeZoneOffset(date, testTimezoneOffset);
+  assertEquals(result, 'ERR_INVALID_DATE');
+});
+
+Deno.test('format ignoring milliseconds', () =>
+{
+  const date = new Date('2023-10-01T12:00:00.123Z');
+  const result = dateToIS08601WithTimeZoneOffset(date, testTimezoneOffset);
+  assertEquals(result, '2023-10-01T21:00:00+09:00');
+});
+

dateToIS08601WithTimeZoneOffset.ts

@@ -0,0 +1,48 @@
+/**
+ * Render an [ISO 8601])(https://xkcd.com/1179/) style date in the browser's local timezone,
+ * e.g. `2021-03-06T16:45:14+09:00`.
+ *
+ * This was originally developed to have an unambiguous and machine-parseable (but still fairly human-friendly) date-formatting mechanism for viewing and copying log data.
+ *
+ * However, it might be generally useful any time you want an ISO 8601 date.
+ */
+export const dateToIS08601WithTimeZoneOffset = (
+  date: Date = new Date(),
+  timeZoneOffset?: number,
+) =>
+{
+  // We can't do better than this in JS, if we don't want to throw an error...
+  if (isNaN(date.getTime())) {
+    return "ERR_INVALID_DATE";
+  }
+
+  // Thanks, Obama! https://stackoverflow.com/questions/17415579/how-to-iso-8601-format-a-date-with-timezone-offset-in-javascript
+
+  const offset = timeZoneOffset ?? date.getTimezoneOffset();
+
+  const tzo = -offset;
+  const dif = tzo >= 0 ? '+' : '-';
+  const pad = (num: number) =>
+  {
+    const norm = Math.floor(Math.abs(num));
+    return (norm < 10 ? '0' : '') + norm;
+  };
+
+  return (
+    date.getFullYear()
+    + '-'
+    + pad(date.getMonth() + 1)
+    + '-'
+    + pad(date.getDate())
+    + 'T'
+    + pad(date.getHours())
+    + ':'
+    + pad(date.getMinutes())
+    + ':'
+    + pad(date.getSeconds())
+    + dif
+    + pad(tzo / 60)
+    + ':'
+    + pad(tzo % 60)
+  );
+};

deno.json

@@ -0,0 +1,8 @@
+{
+  "name": "@axhxrx/date",
+  "version": "0.1.0",
+  "exports": "./mod.ts",
+  "tasks": {
+    "dev": "deno run --watch main.ts"
+  }
+}

deno.lock

@@ -0,0 +1,5 @@
+import { dateToFormat } from "./dateToFormat.ts";
+
+if (import.meta.main) {
+  console.log(dateToFormat("YYYY-MM-DD HH:mm:ss"));
+}