Date Handling

/**
 * Codec that parses ISO date strings to Date objects
 * Handles ISO 8601 format and encodes Date objects back to ISO strings
 */
interface DateFromISOStringC extends t.Type<Date, string, unknown> {}
const DateFromISOString: DateFromISOStringC;

import { DateFromISOString } from "io-ts-types";

const result1 = DateFromISOString.decode("2023-12-25T10:30:00.000Z");
// Right(Date object representing December 25, 2023 at 10:30 AM UTC)

const result2 = DateFromISOString.decode("2023-12-25T10:30:00Z");
// Right(Date object) - also accepts without milliseconds

const result3 = DateFromISOString.decode("invalid-date");
// Left([ValidationError])

const result4 = DateFromISOString.decode("");
// Left([ValidationError])

// Encoding Date back to ISO string
const date = new Date("2023-12-25T10:30:00.000Z");
const encoded = DateFromISOString.encode(date);
// "2023-12-25T10:30:00.000Z"

/**
 * Codec that converts millisecond timestamps to Date objects
 * Handles JavaScript Date.getTime() format (milliseconds since epoch)
 */
interface DateFromNumberC extends t.Type<Date, number, unknown> {}
const DateFromNumber: DateFromNumberC;

import { DateFromNumber } from "io-ts-types";

const result1 = DateFromNumber.decode(1703505000000);
// Right(Date object representing December 25, 2023 at 10:30 AM UTC)

const result2 = DateFromNumber.decode(0);
// Right(Date object representing January 1, 1970 UTC)

const result3 = DateFromNumber.decode(-1);
// Right(Date object representing December 31, 1969 UTC)

// Encoding Date back to millisecond timestamp
const date = new Date("2023-12-25T10:30:00.000Z");
const encoded = DateFromNumber.encode(date);
// 1703505000000

/**
 * Codec that converts Unix timestamps to Date objects
 * Handles seconds since Unix epoch (January 1, 1970 UTC)
 */
interface DateFromUnixTimeC extends t.Type<Date, number, unknown> {}
const DateFromUnixTime: DateFromUnixTimeC;

import { DateFromUnixTime } from "io-ts-types";

const result1 = DateFromUnixTime.decode(1703505000);
// Right(Date object representing December 25, 2023 at 10:30 AM UTC)

const result2 = DateFromUnixTime.decode(0);
// Right(Date object representing January 1, 1970 UTC)

const result3 = DateFromUnixTime.decode(-1);
// Right(Date object representing December 31, 1969 UTC)

// Encoding Date back to Unix timestamp
const date = new Date("2023-12-25T10:30:00.000Z");
const encoded = DateFromUnixTime.encode(date);
// 1703505000

/**
 * Codec that validates values are Date instances
 * Uses instanceof check for runtime Date validation
 */
interface DateC extends t.Type<Date, Date, unknown> {}
const date: DateC;

import { date } from "io-ts-types";

const result1 = date.decode(new Date());
// Right(Date object)

const result2 = date.decode("2023-12-25");
// Left([ValidationError]) - string is not a Date instance

const result3 = date.decode(1703505000000);
// Left([ValidationError]) - number is not a Date instance

// Identity encoding (Date -> Date)
const dateObj = new Date();
const encoded = date.encode(dateObj);
// Same Date object

import * as t from "io-ts";
import { DateFromISOString, DateFromUnixTime } from "io-ts-types";

const Event = t.type({
  id: t.number,
  title: t.string,
  createdAt: DateFromISOString,    // ISO format from modern APIs
  scheduledAt: DateFromUnixTime,   // Unix timestamp from legacy systems
  updatedAt: DateFromISOString
});

const eventData = {
  id: 1,
  title: "Team Meeting",
  createdAt: "2023-12-25T10:30:00.000Z",
  scheduledAt: 1703505000,  // Unix timestamp
  updatedAt: "2023-12-25T11:00:00.000Z"
};

const parsed = Event.decode(eventData);
// Right({ 
//   id: 1, 
//   title: "Team Meeting", 
//   createdAt: Date, 
//   scheduledAt: Date, 
//   updatedAt: Date 
// })

import * as t from "io-ts";
import { DateFromNumber, DateFromISOString } from "io-ts-types";

const DatabaseRecord = t.type({
  id: t.string,
  created_at: DateFromNumber,     // Stored as millisecond timestamp
  expires_at: DateFromISOString,  // Stored as ISO string
  data: t.record(t.string, t.unknown)
});

const record = {
  id: "user_123",
  created_at: 1703505000000,
  expires_at: "2024-01-25T10:30:00.000Z",
  data: { preferences: { theme: "dark" } }
};

const parsed = DatabaseRecord.decode(record);
// Converts timestamps to proper Date objects

import * as t from "io-ts";
import { DateFromISOString } from "io-ts-types";

const EventForm = t.type({
  title: t.string,
  startDate: DateFromISOString,  // HTML date input provides ISO string
  endDate: DateFromISOString,
  description: t.string
});

// HTML form data (date inputs return ISO strings)
const formData = {
  title: "Conference",
  startDate: "2024-06-15T09:00:00.000Z",
  endDate: "2024-06-15T17:00:00.000Z", 
  description: "Annual tech conference"
};

const validated = EventForm.decode(formData);
// Right({ title: "Conference", startDate: Date, endDate: Date, description: "..." })

import { DateFromISOString, DateFromUnixTime } from "io-ts-types";

// Unix timestamps are always UTC
const utcTime = DateFromUnixTime.decode(1703505000);
// Right(Date representing UTC time)

// ISO strings can include timezone information
const isoWithTz = DateFromISOString.decode("2023-12-25T10:30:00+02:00");
// Right(Date object automatically adjusted to local timezone)

const isoUtc = DateFromISOString.decode("2023-12-25T10:30:00.000Z");
// Right(Date object in UTC)

import * as t from "io-ts-types";
import { DateFromISOString } from "io-ts-types";

const DateRange = t.type({
  start: DateFromISOString,
  end: DateFromISOString
});

const range = {
  start: "2023-12-25T10:00:00.000Z",
  end: "2023-12-25T18:00:00.000Z"
};

const decoded = DateRange.decode(range);
if (decoded._tag === "Right") {
  const { start, end } = decoded.right;
  const durationMs = end.getTime() - start.getTime();
  const durationHours = durationMs / (1000 * 60 * 60);
  console.log(`Duration: ${durationHours} hours`); // Duration: 8 hours
}