@edumalin/platform 3.0.0

package/src/temporal/duration/string/as-duration-string.spec.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+
+import { asDurationString } from './as-duration-string.js';
+
+describe('As duration string', () => {
+  it('can build a duration string from a string', () => {
+    // given: a duration string
+    const value = 'P1DT12H';
+
+    // when: safely casting to a duration string
+    const durationString = asDurationString(value);
+
+    // expect: the duration string to be valid
+    expect(durationString).toBe(value);
+  });
+
+  it('can build a duration string from a duration object', () => {
+    // given: a duration object
+    const value = 'P1DT12H';
+    const duration = Temporal.Duration.from(value);
+
+    // when: safely casting to a duration string
+    const durationString = asDurationString(duration);
+
+    // expect: the duration string to be valid
+    expect(durationString).toBe(value);
+  });
+
+  it('throws when given an invalid string', () => {
+    // given: an invalid duration string
+    const value = 'test';
+
+    // expect: an error to be thrown when attempting to cast to a duration string
+    expect(() => asDurationString(value)).toThrow(`@edumalin/platform:error:invalidDurationString`);
+  });
+});

package/src/temporal/duration/string/as-duration-string.ts

@@ -0,0 +1,22 @@
+import { temporalError } from '../../temporal.error.js';
+import { type DurationString } from './duration-string.js';
+
+/**
+ * Safely casts a value to a duration string
+ *
+ * @param value Value
+ * @returns Duration string
+ */
+export function asDurationString(value: unknown): DurationString {
+  if (
+    typeof value === 'string' ||
+    (typeof value === 'object' && value !== null && value instanceof Temporal.Duration)
+  ) {
+    try {
+      const temporal = typeof value === 'string' ? Temporal.Duration.from(value) : value;
+      return temporal.toString() as DurationString;
+    } catch {}
+  }
+
+  throw temporalError.invalidDurationString({ value });
+}

package/src/temporal/duration/string/duration-string.ts

@@ -0,0 +1,6 @@
+/**
+ * Duration string
+ */
+export type DurationString = `P${string}T${string}` & {
+  readonly __tag_platformTemporalDurationString: unique symbol;
+};

package/src/temporal/duration/string/is-duration-string.ts

@@ -0,0 +1,20 @@
+import { type DurationString } from './duration-string.js';
+
+/**
+ * Tests whether a value is a duration string
+ *
+ * @param value Value
+ * @returns true if the value is a duration string
+ */
+export function isDurationString(value: unknown): value is DurationString {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  try {
+    Temporal.Duration.from(value);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/temporal/duration/string/validate-duration-string.ts

@@ -0,0 +1,14 @@
+import { temporalError } from '../../temporal.error.js';
+import { type DurationString } from './duration-string.js';
+import { isDurationString } from './is-duration-string.js';
+
+/**
+ * Validates that a value is a duration string
+ *
+ * @param value Value
+ */
+export function validateDurationString(value: unknown): asserts value is DurationString {
+  if (!isDurationString(value)) {
+    throw temporalError.invalidDurationString({ value });
+  }
+}

package/src/temporal/error/invalid-date-interval-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid date interval string error properties
+ */
+export interface InvalidDateIntervalStringErrorProperties {
+  readonly value: unknown;
+}

package/src/temporal/error/invalid-date-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid date string error properties
+ */
+export interface InvalidDateStringErrorProperties {
+  readonly value: unknown;
+}

package/src/temporal/error/invalid-date-time-interval-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid date time interval string error properties
+ */
+export interface InvalidDateTimeIntervalStringErrorProperties {
+  readonly value: unknown;
+}

package/src/temporal/error/invalid-date-time-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid date time string error properties
+ */
+export interface InvalidDateTimeStringErrorProperties {
+  readonly value: unknown;
+}

package/src/temporal/error/invalid-duration-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid duration string error properties
+ */
+export interface InvalidDurationStringErrorProperties {
+  readonly value: unknown;
+}

package/src/temporal/error/invalid-time-interval-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid time interval string error properties
+ */
+export interface InvalidTimeIntervalStringErrorProperties {
+  readonly value: unknown;
+}

package/src/temporal/error/invalid-time-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid time string error properties
+ */
+export interface InvalidTimeStringErrorProperties {
+  readonly value: unknown;
+}

package/src/temporal/index.ts

@@ -0,0 +1,39 @@
+export { asDateIntervalString } from './date-interval/string/as-date-interval-string.js';
+export { asDateString } from './date/string/as-date-string.js';
+export { asDateTimeString } from './date-time/string/as-date-time-string.js';
+export { asDateTimeIntervalString } from './date-time-interval/string/as-date-time-interval-string.js';
+export { asDurationString } from './duration/string/as-duration-string.js';
+export { asTimeIntervalString } from './time-interval/string/as-time-interval-string.js';
+export { asTimeString } from './time/string/as-time-string.js';
+export { currentDateString } from './date/string/current-date-string.js';
+export { currentDateTimeString } from './date-time/string/current-date-time-string.js';
+export { currentTimeString } from './time/string/current-time-string.js';
+export { type DateIntervalString } from './date-interval/string/date-interval-string.js';
+export { type DateString } from './date/string/date-string.js';
+export { type DateTimeIntervalString } from './date-time-interval/string/date-time-interval-string.js';
+export { type DateTimeString } from './date-time/string/date-time-string.js';
+export { dateTimeStringToDateString } from './date-time/string/date-time-string-to-date-string.js';
+export { dateTimeStringToInstant } from './date-time/string/date-time-string-to-instant.js';
+export { dateToStartOfWeek } from './date/date-to-start-of-week.js';
+export { type DurationString } from './duration/string/duration-string.js';
+export { type InvalidDateIntervalStringErrorProperties } from './error/invalid-date-interval-string-error-properties.js';
+export { type InvalidDateStringErrorProperties } from './error/invalid-date-string-error-properties.js';
+export { type InvalidDateTimeIntervalStringErrorProperties } from './error/invalid-date-time-interval-string-error-properties.js';
+export { type InvalidDateTimeStringErrorProperties } from './error/invalid-date-time-string-error-properties.js';
+export { type InvalidDurationStringErrorProperties } from './error/invalid-duration-string-error-properties.js';
+export { type InvalidTimeIntervalStringErrorProperties } from './error/invalid-time-interval-string-error-properties.js';
+export { type InvalidTimeStringErrorProperties } from './error/invalid-time-string-error-properties.js';
+export { isDateString } from './date/string/is-date-string.js';
+export { isDateTimeIntervalString } from './date-time-interval/string/is-date-time-interval-string.js';
+export { isDateTimeString } from './date-time/string/is-date-time-string.js';
+export { isDurationString } from './duration/string/is-duration-string.js';
+export { isTimeIntervalString } from './time-interval/string/is-time-interval-string.js';
+export { isTimeString } from './time/string/is-time-string.js';
+export { temporalError } from './temporal.error.js';
+export { validateDateString } from './date/string/validate-date-string.js';
+export { validateDateTimeString } from './date-time/string/validate-date-time-string.js';
+export { validateDurationString } from './duration/string/validate-duration-string.js';
+export { validateTimeIntervalString } from './time-interval/string/validate-time-interval-string.js';
+export { validateTimeString } from './time/string/validate-time-string.js';
+export { type TimeIntervalString } from './time-interval/string/time-interval-string.js';
+export { type TimeString } from './time/string/time-string.js';

package/src/temporal/polyfill/index.spec.ts

@@ -0,0 +1,21 @@
+import { Intl as IntlPolyfill, Temporal as TemporalPolyfill, toTemporalInstant } from 'temporal-polyfill';
+import { describe, expect, it } from 'vitest';
+
+import '.';
+
+describe('Temporal polyfill', () => {
+  it('replaces the standard Intl with the polyfill Intl', () => {
+    // expect: Intl to be replaced with Intl from the Temporal polyfill
+    expect(globalThis.Intl).toBe(IntlPolyfill);
+  });
+
+  it('makes Temporal globally available', () => {
+    // expect: Temporal to be globally available
+    expect(globalThis.Temporal).toBe(TemporalPolyfill);
+  });
+
+  it('adds toTemporalInstant to the standard Date object', () => {
+    // expect: Date to have a toTemporalInstance method
+    expect(Date.prototype.toTemporalInstant).toBe(toTemporalInstant);
+  });
+});

package/src/temporal/polyfill/index.ts

@@ -0,0 +1,5 @@
+import { Intl as IntlPolyfill, Temporal as TemporalPolyfill, toTemporalInstant } from 'temporal-polyfill';
+
+globalThis.Intl = IntlPolyfill as unknown as typeof globalThis.Intl;
+globalThis.Temporal = TemporalPolyfill;
+Date.prototype.toTemporalInstant = toTemporalInstant;

package/src/temporal/polyfill/types/temporal.d.ts

@@ -0,0 +1,75 @@
+import {
+  type Intl as IntlPolyfill,
+  type Temporal as TemporalPolyfill,
+  type toTemporalInstant,
+} from 'temporal-polyfill';
+
+declare global {
+  interface Date {
+    toTemporalInstant: typeof toTemporalInstant;
+  }
+
+  namespace Temporal {
+    export type ArithmeticOptions = TemporalPolyfill.ArithmeticOptions;
+    export type AssignmentOptions = TemporalPolyfill.AssignmentOptions;
+    export type ComparisonResult = TemporalPolyfill.ComparisonResult;
+    export type DateTimeUnit = TemporalPolyfill.DateTimeUnit;
+    export type DateUnit = TemporalPolyfill.DateUnit;
+    export type DurationOptions = TemporalPolyfill.DurationOptions;
+    export type RoundingMode = TemporalPolyfill.RoundingMode;
+    export type TimeUnit = TemporalPolyfill.TimeUnit;
+    export type ToInstantOptions = TemporalPolyfill.ToInstantOptions;
+    export type ZonedDateTimeAssignmentOptions = TemporalPolyfill.ZonedDateTimeAssignmentOptions;
+    export type PluralUnit<T extends DateTimeUnit> = TemporalPolyfill.PluralUnit<T>;
+    export type LargestUnit<T extends DateTimeUnit> = TemporalPolyfill.LargestUnit<T>;
+    export type SmallestUnit<T extends DateTimeUnit> = TemporalPolyfill.SmallestUnit<T>;
+    export type TotalUnit<T extends DateTimeUnit> = TemporalPolyfill.TotalUnit<T>;
+    export type ToStringPrecisionOptions = TemporalPolyfill.ToStringPrecisionOptions;
+    export type ShowCalendarOption = TemporalPolyfill.ShowCalendarOption;
+    export type CalendarTypeToStringOptions = TemporalPolyfill.CalendarTypeToStringOptions;
+    export type ZonedDateTimeToStringOptions = TemporalPolyfill.ZonedDateTimeToStringOptions;
+    export type InstantToStringOptions = TemporalPolyfill.InstantToStringOptions;
+    export type DifferenceOptions<T extends DateTimeUnit> = TemporalPolyfill.DifferenceOptions<T>;
+    export type RoundTo<T extends DateTimeUnit> = TemporalPolyfill.RoundTo<T>;
+    export type DurationRoundTo = TemporalPolyfill.DurationRoundTo;
+    export type DurationTotalOf = TemporalPolyfill.DurationTotalOf;
+    export type DurationArithmeticOptions = TemporalPolyfill.DurationArithmeticOptions;
+    export type DurationLike = TemporalPolyfill.DurationLike;
+    export type Duration = TemporalPolyfill.Duration;
+    export const Duration: typeof TemporalPolyfill.Duration;
+    export type Instant = TemporalPolyfill.Instant;
+    export const Instant: typeof TemporalPolyfill.Instant;
+    export type CalendarLike = TemporalPolyfill.CalendarLike;
+    export type PlainDateLike = TemporalPolyfill.PlainDateLike;
+    export type PlainDate = TemporalPolyfill.PlainDate;
+    export const PlainDate: typeof TemporalPolyfill.PlainDate;
+    export type PlainDateTimeLike = TemporalPolyfill.PlainDateTimeLike;
+    export type PlainDateTime = TemporalPolyfill.PlainDateTime;
+    export const PlainDateTime: typeof TemporalPolyfill.PlainDateTime;
+    export type PlainMonthDayLike = TemporalPolyfill.PlainMonthDayLike;
+    export type PlainMonthDay = TemporalPolyfill.PlainMonthDay;
+    export const PlainMonthDay: typeof TemporalPolyfill.PlainMonthDay;
+    export type PlainTimeLike = TemporalPolyfill.PlainTimeLike;
+    export type PlainTime = TemporalPolyfill.PlainTime;
+    export const PlainTime: typeof TemporalPolyfill.PlainTime;
+    export type TimeZoneLike = TemporalPolyfill.TimeZoneLike;
+    export type PlainYearMonthLike = TemporalPolyfill.PlainYearMonthLike;
+    export type PlainYearMonth = TemporalPolyfill.PlainYearMonth;
+    export const PlainYearMonth: typeof TemporalPolyfill.PlainYearMonth;
+    export type ZonedDateTimeLike = TemporalPolyfill.ZonedDateTimeLike;
+    export type ZonedDateTime = TemporalPolyfill.ZonedDateTime;
+    export const ZonedDateTime: typeof TemporalPolyfill.ZonedDateTime;
+    export type Now = TemporalPolyfill.Now;
+    export const Now: typeof TemporalPolyfill.Now;
+  }
+
+  namespace Intl {
+    interface DateTimeFormatRangePart {
+      source: 'shared' | 'startRange' | 'endRange';
+    }
+
+    export type DateTimeFormat = IntlPolyfill.DateTimeFormat;
+    export type DateTimeFormatOptions = IntlPolyfill.DateTimeFormatOptions;
+    export const DateTimeFormat: typeof IntlPolyfill.DateTimeFormat;
+  }
+}

package/src/temporal/temporal.error.ts

@@ -0,0 +1,44 @@
+import { platformDomain } from '@edumalin/platform';
+import { createErrorType, errorProperties } from '@edumalin/platform/error';
+
+import { type InvalidDateIntervalStringErrorProperties } from './error/invalid-date-interval-string-error-properties.js';
+import { type InvalidDateStringErrorProperties } from './error/invalid-date-string-error-properties.js';
+import { type InvalidDateTimeIntervalStringErrorProperties } from './error/invalid-date-time-interval-string-error-properties.js';
+import { type InvalidDateTimeStringErrorProperties } from './error/invalid-date-time-string-error-properties.js';
+import { type InvalidDurationStringErrorProperties } from './error/invalid-duration-string-error-properties.js';
+import { type InvalidTimeIntervalStringErrorProperties } from './error/invalid-time-interval-string-error-properties.js';
+import { type InvalidTimeStringErrorProperties } from './error/invalid-time-string-error-properties.js';
+
+/**
+ * Temporal error
+ */
+export const temporalError = createErrorType(platformDomain, {
+  /**
+   * Invalid date interval string
+   */
+  invalidDateIntervalString: errorProperties<InvalidDateIntervalStringErrorProperties>(),
+  /**
+   * Invalid date string
+   */
+  invalidDateString: errorProperties<InvalidDateStringErrorProperties>(),
+  /**
+   * Invalid date time interval string
+   */
+  invalidDateTimeIntervalString: errorProperties<InvalidDateTimeIntervalStringErrorProperties>(),
+  /**
+   * Invalid date time string
+   */
+  invalidDateTimeString: errorProperties<InvalidDateTimeStringErrorProperties>(),
+  /**
+   * Invalid duration string
+   */
+  invalidDurationString: errorProperties<InvalidDurationStringErrorProperties>(),
+  /**
+   * Invalid time interval string
+   */
+  invalidTimeIntervalString: errorProperties<InvalidTimeIntervalStringErrorProperties>(),
+  /**
+   * Invalid time string
+   */
+  invalidTimeString: errorProperties<InvalidTimeStringErrorProperties>(),
+});

package/src/temporal/time/string/as-time-string.ts

@@ -0,0 +1,22 @@
+import { temporalError } from '../../temporal.error.js';
+import { type TimeString } from './time-string.js';
+
+/**
+ * Safely casts a value to a time string
+ *
+ * @param value value
+ * @returns Time string
+ */
+export function asTimeString(value: unknown): TimeString {
+  if (
+    typeof value === 'string' ||
+    (typeof value === 'object' && value !== null && value instanceof Temporal.PlainTime)
+  ) {
+    try {
+      const temporal = typeof value === 'string' ? Temporal.PlainTime.from(value) : value;
+      return temporal.toString() as TimeString;
+    } catch {}
+  }
+
+  throw temporalError.invalidTimeString({ value });
+}

package/src/temporal/time/string/current-time-string.ts

@@ -0,0 +1,11 @@
+import { asTimeString } from './as-time-string.js';
+import { type TimeString } from './time-string.js';
+
+/**
+ * Returns the current time string
+ *
+ * @returns Current time string
+ */
+export function currentTimeString(): TimeString {
+  return asTimeString(Temporal.Now.plainDateISO());
+}

package/src/temporal/time/string/is-time-string.ts

@@ -0,0 +1,20 @@
+import { type TimeString } from './time-string.js';
+
+/**
+ * Tests whether a value is a time string
+ *
+ * @param value Value
+ * @returns true if the value is a time string
+ */
+export function isTimeString(value: unknown): value is TimeString {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  try {
+    Temporal.PlainTime.from(value);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/temporal/time/string/time-string.ts

@@ -0,0 +1,6 @@
+/**
+ * ISO 8601 time string
+ */
+export type TimeString = `${number}:${number}:${number}${`.${number}` | ''}` & {
+  readonly __tag_platformTemporalTimeString: unique symbol;
+};

package/src/temporal/time/string/validate-time-string.ts

@@ -0,0 +1,14 @@
+import { temporalError } from '../../temporal.error.js';
+import { type TimeString } from './time-string.js';
+import { isTimeString } from './is-time-string.js';
+
+/**
+ * Validates that a value is a time string
+ *
+ * @param value Value
+ */
+export function validateTimeString(value: unknown): asserts value is TimeString {
+  if (!isTimeString(value)) {
+    throw temporalError.invalidTimeString({ value });
+  }
+}

package/src/temporal/time-interval/string/as-time-interval-string.ts

@@ -0,0 +1,13 @@
+import { type TimeIntervalString } from './time-interval-string.js';
+import { validateTimeIntervalString } from './validate-time-interval-string.js';
+
+/**
+ * Safely casts a value to a time interval string
+ *
+ * @param value Value
+ * @returns Time interval string
+ */
+export function asTimeIntervalString(value: unknown): TimeIntervalString {
+  validateTimeIntervalString(value);
+  return value;
+}

package/src/temporal/time-interval/string/is-time-interval-string.ts

@@ -0,0 +1,21 @@
+import { isTimeString } from '../../time/string/is-time-string.js';
+import { type TimeIntervalString } from './time-interval-string.js';
+
+/**
+ * Tests whether a value is a time interval string
+ *
+ * @param value Value
+ * @returns true if the value is a time interval string
+ */
+export function isTimeIntervalString(value: unknown): value is TimeIntervalString {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  const splitValue = value.split('/');
+  if (splitValue.length !== 2) {
+    return false;
+  }
+
+  return splitValue.every(isTimeString);
+}

package/src/temporal/time-interval/string/time-interval-string.ts

@@ -0,0 +1,8 @@
+import { type TimeString } from '../../time/string/time-string.js';
+
+/**
+ * ISO 8601 time interval string
+ */
+export type TimeIntervalString = `${TimeString}/${TimeString}` & {
+  readonly __tag_platformTemporaTimeIntervalString: unique symbol;
+};

package/src/temporal/time-interval/string/validate-time-interval-string.ts

@@ -0,0 +1,14 @@
+import { temporalError } from '../../temporal.error.js';
+import { isTimeIntervalString } from './is-time-interval-string.js';
+import { type TimeIntervalString } from './time-interval-string.js';
+
+/**
+ * Validates that a value is a time interval string
+ *
+ * @param value Value
+ */
+export function validateTimeIntervalString(value: unknown): asserts value is TimeIntervalString {
+  if (!isTimeIntervalString(value)) {
+    throw temporalError.invalidTimeIntervalString({ value });
+  }
+}

package/src/testing/environment/create-test-environment-variables.ts

@@ -0,0 +1,13 @@
+import { platformEnvironmentToEnvironmentVariables, type EnvironmentVariables } from '@edumalin/platform/environment';
+
+import { createTestPlatformEnvironment } from './create-test-platform-environment.js';
+
+/**
+ * Creates a test platform environment
+ *
+ * @returns Test environment variables
+ */
+export function createTestEnvironmentVariables(): EnvironmentVariables {
+  const platformEnvironment = createTestPlatformEnvironment();
+  return platformEnvironmentToEnvironmentVariables(platformEnvironment);
+}

package/src/testing/environment/create-test-platform-environment.ts

@@ -0,0 +1,25 @@
+import { type PlatformEnvironment } from '@edumalin/platform/environment';
+
+import { testPlatformEnvironmentId } from './test-platform-environment-id.js';
+
+/**
+ * Creates a test platform environment
+ *
+ * @param platformEnvironment Platform environment
+ * @returns Test platform environment
+ */
+export function createTestPlatformEnvironment(platformEnvironment?: Partial<PlatformEnvironment>): PlatformEnvironment {
+  const id = platformEnvironment?.id ?? testPlatformEnvironmentId;
+  const name = platformEnvironment?.name ?? 'Test platform environment';
+  const provider = platformEnvironment?.provider ?? 'local';
+  const region = platformEnvironment?.region ?? 'local';
+  const type = platformEnvironment?.type ?? 'local';
+
+  return {
+    id,
+    name,
+    provider,
+    region,
+    type,
+  };
+}

package/src/testing/environment/test-platform-environment-id.ts

@@ -0,0 +1,6 @@
+import { asPlatformEnvironmentId } from '@edumalin/platform/environment';
+
+/**
+ * Test platform environment identifier
+ */
+export const testPlatformEnvironmentId = asPlatformEnvironmentId('test');

package/src/testing/index.ts

@@ -0,0 +1,3 @@
+export { createTestEnvironmentVariables } from './environment/create-test-environment-variables.js';
+export { createTestPlatformEnvironment } from './environment/create-test-platform-environment.js';
+export { testPlatformEnvironmentId } from './environment/test-platform-environment-id.js';

package/src/tsconfig.base.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "rootDir": ".",
+    "paths": {
+      "@edumalin/platform": ["./index.ts"],
+      "@edumalin/platform/collection": ["./collection/index.ts"],
+      "@edumalin/platform/color": ["./color/index.ts"],
+      "@edumalin/platform/domain": ["./domain/index.ts"],
+      "@edumalin/platform/environment": ["./environment/index.ts"],
+      "@edumalin/platform/error": ["./error/index.ts"],
+      "@edumalin/platform/event": ["./event/index.ts"],
+      "@edumalin/platform/functional": ["./functional/index.ts"],
+      "@edumalin/platform/geometry": ["./geometry/index.ts"],
+      "@edumalin/platform/http": ["./http/index.ts"],
+      "@edumalin/platform/http/client": ["./http/client/index.ts"],
+      "@edumalin/platform/http/client/graphql": ["./http/client/graphql/index.ts"],
+      "@edumalin/platform/http/client/testing": ["./http/client/testing/index.ts"],
+      "@edumalin/platform/i18n": ["./i18n/index.ts"],
+      "@edumalin/platform/language": ["./language/index.ts"],
+      "@edumalin/platform/locale": ["./locale/index.ts"],
+      "@edumalin/platform/random": ["./random/index.ts"],
+      "@edumalin/platform/reactive": ["./reactive/index.ts"],
+      "@edumalin/platform/reactive/polyfill": ["./reactive/polyfill/index.ts"],
+      "@edumalin/platform/temporal": ["./temporal/index.ts"],
+      "@edumalin/platform/temporal/polyfill": ["./temporal/polyfill/index.ts"],
+      "@edumalin/platform/testing": ["./testing/index.ts"],
+      "@edumalin/platform/typescript": ["./typescript/index.ts"],
+      "@edumalin/platform/url": ["./url/index.ts"],
+      "@edumalin/platform/uuid": ["./uuid/index.ts"]
+    }
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules", "dist", "./**/*.spec.ts"]
+}

package/src/tsconfig.cjs.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "../dist/cjs"
+  }
+}

package/src/tsconfig.esm.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "esnext",
+    "outDir": "../dist/esm"
+  }
+}

package/src/tsconfig.spec.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "./tsconfig.esm.json",
+  "compilerOptions": {
+    "module": "esnext",
+    "types": []
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/src/tsconfig.types.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig.json",
+  "extends": "./tsconfig.esm.json",
+  "compilerOptions": {
+    "composite": true,
+    "removeComments": false,
+    "declaration": true,
+    "declarationMap": true,
+    "declarationDir": "../dist/types",
+    "emitDeclarationOnly": true,
+    "module": "es2015"
+  }
+}