@northguild/gmt 1.18.0 → 1.20.0

package/dist/intermodal/format/index.js

@@ -0,0 +1,14 @@
+export * from "./bolTimestamp.js";
+export * from "./formatEdifactDate.js";
+export * from "./formatEdifactDatePeriod.js";
+export * from "./formatEdifactDateTime.js";
+export * from "./formatEdifactDateTimePeriod.js";
+export * from "./formatEdifactOffsetDateTime.js";
+export * from "./formatEdifactTime.js";
+export * from "./formatEpcisEvent.js";
+export * from "./formatX12Date.js";
+export * from "./formatX12DateRange.js";
+export * from "./formatX12DateTime.js";
+export * from "./formatX12DateTimeRange.js";
+export * from "./formatX12Time.js";
+export * from "./formatX12TimeElement.js";

package/dist/intermodal/index.d.ts

@@ -1,2 +1,5 @@
-export * from "@js-temporal/polyfill";
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calculate/index.js";
+export * from "./format/index.js";
+export * from "./parse/index.js";
+export * from "./validate/index.js";

package/dist/intermodal/index.js

@@ -1,3 +1,6 @@
-// Re-export the Temporal polyfill (`Temporal`, `Intl`, `toTemporalInstant`) so every namespace subpath offers it
-export * from "@js-temporal/polyfill";
+// Re-export `Temporal`, `Intl` and `toTemporalInstant` from the internal seam so every namespace subpath offers them
+export { Intl, Temporal, toTemporalInstant } from "../internal/temporal.js";
 export * from "./calculate/index.js";
+export * from "./format/index.js";
+export * from "./parse/index.js";
+export * from "./validate/index.js";

package/dist/intermodal/parse/classifyEdifactDtmFormat.d.ts

@@ -0,0 +1,48 @@
+import type { EdifactDtmFormatClass } from "../../types/edi.js";
+/**
+ * Name the kind of value a UN/EDIFACT data element 2379 format code states, and return the code
+ * narrowed to that kind, so a code that arrives as data reaches the function that reads it.
+ *
+ * Each kind has its own parser, formatter and validator, and each takes only its own codes. A
+ * generic `DTM` reader holds the code as a plain string: it calls this function, tests `kind`,
+ * and passes `format` on. Testing `kind` narrows `format` to that kind's union, so the call
+ * needs no cast.
+ *
+ * ### Kinds
+ * | `kind` | Codes | Read by |
+ * |---|---|---|
+ * | `"date"` | `102` | `parseEdifactDate` |
+ * | `"time"` | `401`, `402` | `parseEdifactTime` |
+ * | `"dateTime"` | `203`, `204` | `parseEdifactDateTime` |
+ * | `"offsetDateTime"` | `205`, `208`, `303`, `304` | `parseEdifactOffsetDateTime` |
+ * | `"datePeriod"` | `718` | `parseEdifactDatePeriod` |
+ * | `"dateTimePeriod"` | `719` | `parseEdifactDateTimePeriod` |
+ *
+ * - **The narrowing pattern.** With `const classified = classifyEdifactDtmFormat(code)`, the
+ *   line `if (classified?.kind === "date") parseEdifactDate(value, classified.format)` compiles
+ *   with no cast: inside the test, `classified.format` is `EdifactDateFormat`.
+ * - Both members are always present, and each call returns a new object.
+ * - Returns `null` for every code no function reads: the two-digit-year codes (`101`, `201`,
+ *   `202`, `206`, `207`, `301`, `302`, `713`, `717`), `209`, `404`, `406` and every other 2379
+ *   code.
+ * - Matching is exact: `" 203"`, `"0203"` and the number `203` are not codes.
+ * - Returns a result exactly when `isValidEdifactDtmFormat` is true.
+ *
+ * @param format The data element 2379 format code, as it arrives (e.g. "203")
+ * @returns `{ kind, format }`, or null on invalid input
+ *
+ * @example classifyEdifactDtmFormat("102") // { kind: "date", format: "102" }
+ * @example classifyEdifactDtmFormat("401") // { kind: "time", format: "401" }
+ * @example classifyEdifactDtmFormat("402") // { kind: "time", format: "402" }
+ * @example classifyEdifactDtmFormat("203") // { kind: "dateTime", format: "203" }
+ * @example classifyEdifactDtmFormat("204") // { kind: "dateTime", format: "204" }
+ * @example classifyEdifactDtmFormat("205") // { kind: "offsetDateTime", format: "205" }
+ * @example classifyEdifactDtmFormat("208") // { kind: "offsetDateTime", format: "208" }
+ * @example classifyEdifactDtmFormat("303") // { kind: "offsetDateTime", format: "303" }
+ * @example classifyEdifactDtmFormat("304") // { kind: "offsetDateTime", format: "304" }
+ * @example classifyEdifactDtmFormat("718") // { kind: "datePeriod", format: "718" }
+ * @example classifyEdifactDtmFormat("719") // { kind: "dateTimePeriod", format: "719" }
+ * @example classifyEdifactDtmFormat("101") // null (a two-digit year is not read)
+ * @example classifyEdifactDtmFormat("602") // null (not a supported code)
+ */
+export declare function classifyEdifactDtmFormat(format: string): EdifactDtmFormatClass | null;

package/dist/intermodal/parse/classifyEdifactDtmFormat.js

@@ -0,0 +1,55 @@
+import { ediCodeOf } from "../../internal/ediGrammar.js";
+/**
+ * Name the kind of value a UN/EDIFACT data element 2379 format code states, and return the code
+ * narrowed to that kind, so a code that arrives as data reaches the function that reads it.
+ *
+ * Each kind has its own parser, formatter and validator, and each takes only its own codes. A
+ * generic `DTM` reader holds the code as a plain string: it calls this function, tests `kind`,
+ * and passes `format` on. Testing `kind` narrows `format` to that kind's union, so the call
+ * needs no cast.
+ *
+ * ### Kinds
+ * | `kind` | Codes | Read by |
+ * |---|---|---|
+ * | `"date"` | `102` | `parseEdifactDate` |
+ * | `"time"` | `401`, `402` | `parseEdifactTime` |
+ * | `"dateTime"` | `203`, `204` | `parseEdifactDateTime` |
+ * | `"offsetDateTime"` | `205`, `208`, `303`, `304` | `parseEdifactOffsetDateTime` |
+ * | `"datePeriod"` | `718` | `parseEdifactDatePeriod` |
+ * | `"dateTimePeriod"` | `719` | `parseEdifactDateTimePeriod` |
+ *
+ * - **The narrowing pattern.** With `const classified = classifyEdifactDtmFormat(code)`, the
+ *   line `if (classified?.kind === "date") parseEdifactDate(value, classified.format)` compiles
+ *   with no cast: inside the test, `classified.format` is `EdifactDateFormat`.
+ * - Both members are always present, and each call returns a new object.
+ * - Returns `null` for every code no function reads: the two-digit-year codes (`101`, `201`,
+ *   `202`, `206`, `207`, `301`, `302`, `713`, `717`), `209`, `404`, `406` and every other 2379
+ *   code.
+ * - Matching is exact: `" 203"`, `"0203"` and the number `203` are not codes.
+ * - Returns a result exactly when `isValidEdifactDtmFormat` is true.
+ *
+ * @param format The data element 2379 format code, as it arrives (e.g. "203")
+ * @returns `{ kind, format }`, or null on invalid input
+ *
+ * @example classifyEdifactDtmFormat("102") // { kind: "date", format: "102" }
+ * @example classifyEdifactDtmFormat("401") // { kind: "time", format: "401" }
+ * @example classifyEdifactDtmFormat("402") // { kind: "time", format: "402" }
+ * @example classifyEdifactDtmFormat("203") // { kind: "dateTime", format: "203" }
+ * @example classifyEdifactDtmFormat("204") // { kind: "dateTime", format: "204" }
+ * @example classifyEdifactDtmFormat("205") // { kind: "offsetDateTime", format: "205" }
+ * @example classifyEdifactDtmFormat("208") // { kind: "offsetDateTime", format: "208" }
+ * @example classifyEdifactDtmFormat("303") // { kind: "offsetDateTime", format: "303" }
+ * @example classifyEdifactDtmFormat("304") // { kind: "offsetDateTime", format: "304" }
+ * @example classifyEdifactDtmFormat("718") // { kind: "datePeriod", format: "718" }
+ * @example classifyEdifactDtmFormat("719") // { kind: "dateTimePeriod", format: "719" }
+ * @example classifyEdifactDtmFormat("101") // null (a two-digit year is not read)
+ * @example classifyEdifactDtmFormat("602") // null (not a supported code)
+ */
+export function classifyEdifactDtmFormat(format) {
+    const entry = ediCodeOf("edifact", format);
+    // The layout table is typed kind by kind from the format unions, so the kind an entry carries
+    // is the kind of the union its code belongs to.
+    return entry === null
+        ? null
+        : { kind: entry.kind, format };
+}

package/dist/intermodal/parse/classifyX12DateTimePeriodFormat.d.ts

@@ -0,0 +1,50 @@
+import type { X12DateTimePeriodFormatClass } from "../../types/edi.js";
+/**
+ * Name the kind of value an X12 data element 1250 format qualifier states, and return the code
+ * narrowed to that kind, so a code that arrives as data reaches the function that reads it.
+ *
+ * Each kind has its own parser, formatter and validator, and each takes only its own codes. A
+ * generic `DTP` reader holds `DTP-02` as a plain string: it calls this function, tests `kind`,
+ * and passes `format` on. Testing `kind` narrows `format` to that kind's union, so the call
+ * needs no cast. Codes are release 005010, read from
+ * [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-005010/element/1250); the X12
+ * text itself was not reached.
+ *
+ * ### Kinds
+ * | `kind` | Codes | Read by |
+ * |---|---|---|
+ * | `"date"` | `D8`, `DB` | `parseX12Date` |
+ * | `"time"` | `TM`, `TS` | `parseX12Time(value, format)` |
+ * | `"dateTime"` | `DT`, `RTS` | `parseX12DateTime` |
+ * | `"dateRange"` | `RD8`, `RD` | `parseX12DateRange` |
+ * | `"dateTimeRange"` | `RDT`, `DTS` | `parseX12DateTimeRange` |
+ *
+ * - **The narrowing pattern.** With `const classified = classifyX12DateTimePeriodFormat(code)`,
+ *   the line `if (classified?.kind === "date") parseX12Date(value, classified.format)` compiles
+ *   with no cast: inside the test, `classified.format` is `X12DateFormat`.
+ * - Both members are always present, and each call returns a new object.
+ * - `RTS` is one date-time despite its `R`, and `DTS` is a range despite having none.
+ * - Returns `null` for every code no function reads: the two-digit-year codes (`D6`, `TT`, `TR`,
+ *   `RD6`, `TU`), `TC`, `EH`, `DDT`, `DTD`, `RTM`, `UN` and every other 1250 code.
+ * - This is a format qualifier, not a time code: `TS` here is the format `HHMMSS`. Classify a
+ *   data element 623 time code with `classifyX12TimeCode`.
+ * - Matching is exact: `"d8"` and `" D8"` are not codes.
+ * - Returns a result exactly when `isValidX12DateTimePeriodFormat` is true.
+ *
+ * @param format X12 data element 1250 format qualifier, as it arrives (e.g. "D8")
+ * @returns `{ kind, format }`, or null on invalid input
+ *
+ * @example classifyX12DateTimePeriodFormat("D8") // { kind: "date", format: "D8" }
+ * @example classifyX12DateTimePeriodFormat("DB") // { kind: "date", format: "DB" }
+ * @example classifyX12DateTimePeriodFormat("TM") // { kind: "time", format: "TM" }
+ * @example classifyX12DateTimePeriodFormat("TS") // { kind: "time", format: "TS" }
+ * @example classifyX12DateTimePeriodFormat("DT") // { kind: "dateTime", format: "DT" }
+ * @example classifyX12DateTimePeriodFormat("RTS") // { kind: "dateTime", format: "RTS" }
+ * @example classifyX12DateTimePeriodFormat("RD8") // { kind: "dateRange", format: "RD8" }
+ * @example classifyX12DateTimePeriodFormat("RD") // { kind: "dateRange", format: "RD" }
+ * @example classifyX12DateTimePeriodFormat("RDT") // { kind: "dateTimeRange", format: "RDT" }
+ * @example classifyX12DateTimePeriodFormat("DTS") // { kind: "dateTimeRange", format: "DTS" }
+ * @example classifyX12DateTimePeriodFormat("D6") // null (a two-digit year is not read)
+ * @example classifyX12DateTimePeriodFormat("UN") // null (unstructured: nothing to read)
+ */
+export declare function classifyX12DateTimePeriodFormat(format: string): X12DateTimePeriodFormatClass | null;

package/dist/intermodal/parse/classifyX12DateTimePeriodFormat.js

@@ -0,0 +1,57 @@
+import { ediCodeOf } from "../../internal/ediGrammar.js";
+/**
+ * Name the kind of value an X12 data element 1250 format qualifier states, and return the code
+ * narrowed to that kind, so a code that arrives as data reaches the function that reads it.
+ *
+ * Each kind has its own parser, formatter and validator, and each takes only its own codes. A
+ * generic `DTP` reader holds `DTP-02` as a plain string: it calls this function, tests `kind`,
+ * and passes `format` on. Testing `kind` narrows `format` to that kind's union, so the call
+ * needs no cast. Codes are release 005010, read from
+ * [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-005010/element/1250); the X12
+ * text itself was not reached.
+ *
+ * ### Kinds
+ * | `kind` | Codes | Read by |
+ * |---|---|---|
+ * | `"date"` | `D8`, `DB` | `parseX12Date` |
+ * | `"time"` | `TM`, `TS` | `parseX12Time(value, format)` |
+ * | `"dateTime"` | `DT`, `RTS` | `parseX12DateTime` |
+ * | `"dateRange"` | `RD8`, `RD` | `parseX12DateRange` |
+ * | `"dateTimeRange"` | `RDT`, `DTS` | `parseX12DateTimeRange` |
+ *
+ * - **The narrowing pattern.** With `const classified = classifyX12DateTimePeriodFormat(code)`,
+ *   the line `if (classified?.kind === "date") parseX12Date(value, classified.format)` compiles
+ *   with no cast: inside the test, `classified.format` is `X12DateFormat`.
+ * - Both members are always present, and each call returns a new object.
+ * - `RTS` is one date-time despite its `R`, and `DTS` is a range despite having none.
+ * - Returns `null` for every code no function reads: the two-digit-year codes (`D6`, `TT`, `TR`,
+ *   `RD6`, `TU`), `TC`, `EH`, `DDT`, `DTD`, `RTM`, `UN` and every other 1250 code.
+ * - This is a format qualifier, not a time code: `TS` here is the format `HHMMSS`. Classify a
+ *   data element 623 time code with `classifyX12TimeCode`.
+ * - Matching is exact: `"d8"` and `" D8"` are not codes.
+ * - Returns a result exactly when `isValidX12DateTimePeriodFormat` is true.
+ *
+ * @param format X12 data element 1250 format qualifier, as it arrives (e.g. "D8")
+ * @returns `{ kind, format }`, or null on invalid input
+ *
+ * @example classifyX12DateTimePeriodFormat("D8") // { kind: "date", format: "D8" }
+ * @example classifyX12DateTimePeriodFormat("DB") // { kind: "date", format: "DB" }
+ * @example classifyX12DateTimePeriodFormat("TM") // { kind: "time", format: "TM" }
+ * @example classifyX12DateTimePeriodFormat("TS") // { kind: "time", format: "TS" }
+ * @example classifyX12DateTimePeriodFormat("DT") // { kind: "dateTime", format: "DT" }
+ * @example classifyX12DateTimePeriodFormat("RTS") // { kind: "dateTime", format: "RTS" }
+ * @example classifyX12DateTimePeriodFormat("RD8") // { kind: "dateRange", format: "RD8" }
+ * @example classifyX12DateTimePeriodFormat("RD") // { kind: "dateRange", format: "RD" }
+ * @example classifyX12DateTimePeriodFormat("RDT") // { kind: "dateTimeRange", format: "RDT" }
+ * @example classifyX12DateTimePeriodFormat("DTS") // { kind: "dateTimeRange", format: "DTS" }
+ * @example classifyX12DateTimePeriodFormat("D6") // null (a two-digit year is not read)
+ * @example classifyX12DateTimePeriodFormat("UN") // null (unstructured: nothing to read)
+ */
+export function classifyX12DateTimePeriodFormat(format) {
+    const entry = ediCodeOf("x12", format);
+    // The layout table is typed kind by kind from the format unions, so the kind an entry carries
+    // is the kind of the union its code belongs to.
+    return entry === null
+        ? null
+        : { kind: entry.kind, format };
+}

package/dist/intermodal/parse/classifyX12TimeCode.d.ts

@@ -0,0 +1,46 @@
+import type { X12TimeCodeClass } from "../../types/edi.js";
+/**
+ * Say whether an X12 time code (data element 623) states an offset or names a zone, and return
+ * the code narrowed to the function that reads it.
+ *
+ * Data element 623 is the code beside the date and time of an X12 `AT7`, `G62` or `DTM`
+ * segment. 31 of its 56 codes state an offset from UTC and 25 name a zone, and each group has
+ * its own reader. A segment reader holds the code as a plain string: it calls this function,
+ * tests `kind`, and passes `timeCode` on. Testing `kind` narrows `timeCode` to that reader's
+ * union, so the call needs no cast. Codes are release 008010, read from
+ * [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-008010/element/623); the X12
+ * text itself was not reached.
+ *
+ * ### Kinds
+ * | `kind` | Codes | Read by |
+ * |---|---|---|
+ * | `"offset"` | `01`–`29`, `UT`, `GM` | `x12TimeCodeOffset` |
+ * | `"zone"` | `AD`, `AS`, `AT`, `CD`, `CS`, `CT`, `ED`, `ES`, `ET`, `HD`, `HS`, `HT`, `MD`, `MS`, `MT`, `ND`, `NS`, `NT`, `PD`, `PS`, `PT`, `TD`, `TS`, `TT`, `LT` | `x12TimeCodeZone` |
+ *
+ * - **The narrowing pattern.** With `const classified = classifyX12TimeCode(code)`, the line
+ *   `if (classified?.kind === "offset") x12TimeCodeOffset(classified.timeCode)` compiles with
+ *   no cast: inside the test, `classified.timeCode` is `X12OffsetTimeCode`. The `"zone"` branch
+ *   passes `classified.timeCode` to `x12TimeCodeZone` the same way.
+ * - Both members are always present, and each call returns a new object.
+ * - `GM` ("Greenwich Mean Time") is an offset code: GMT reads it as `+00:00`, as
+ *   `x12TimeCodeOffset` explains.
+ * - `25`–`29` were added in release 006010. The function takes no release, so it reads them.
+ * - This is a time code, not a format qualifier: `TS` here is Atlantic Standard Time. Classify
+ *   a data element 1250 code with `classifyX12DateTimePeriodFormat`.
+ * - Matching is exact: two characters, upper case, no padding.
+ * - Returns `null` for a code that is not one of the 56 and for a non-string. It returns a
+ *   result exactly when `isValidX12TimeCode` is true.
+ *
+ * @param timeCode X12 data element 623 time code, as it arrives (e.g. "20")
+ * @returns `{ kind, timeCode }`, or null on invalid input
+ *
+ * @example classifyX12TimeCode("20") // { kind: "offset", timeCode: "20" }
+ * @example classifyX12TimeCode("UT") // { kind: "offset", timeCode: "UT" }
+ * @example classifyX12TimeCode("GM") // { kind: "offset", timeCode: "GM" }
+ * @example classifyX12TimeCode("ES") // { kind: "zone", timeCode: "ES" }
+ * @example classifyX12TimeCode("ET") // { kind: "zone", timeCode: "ET" }
+ * @example classifyX12TimeCode("LT") // { kind: "zone", timeCode: "LT" }
+ * @example classifyX12TimeCode("EST") // null (not a 623 code)
+ * @example classifyX12TimeCode("et") // null (matching is exact)
+ */
+export declare function classifyX12TimeCode(timeCode: string): X12TimeCodeClass | null;

package/dist/intermodal/parse/classifyX12TimeCode.js

@@ -0,0 +1,57 @@
+import { x12TimeCodeOffset } from "./x12TimeCodeOffset.js";
+import { x12TimeCodeZone } from "./x12TimeCodeZone.js";
+/**
+ * Say whether an X12 time code (data element 623) states an offset or names a zone, and return
+ * the code narrowed to the function that reads it.
+ *
+ * Data element 623 is the code beside the date and time of an X12 `AT7`, `G62` or `DTM`
+ * segment. 31 of its 56 codes state an offset from UTC and 25 name a zone, and each group has
+ * its own reader. A segment reader holds the code as a plain string: it calls this function,
+ * tests `kind`, and passes `timeCode` on. Testing `kind` narrows `timeCode` to that reader's
+ * union, so the call needs no cast. Codes are release 008010, read from
+ * [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-008010/element/623); the X12
+ * text itself was not reached.
+ *
+ * ### Kinds
+ * | `kind` | Codes | Read by |
+ * |---|---|---|
+ * | `"offset"` | `01`–`29`, `UT`, `GM` | `x12TimeCodeOffset` |
+ * | `"zone"` | `AD`, `AS`, `AT`, `CD`, `CS`, `CT`, `ED`, `ES`, `ET`, `HD`, `HS`, `HT`, `MD`, `MS`, `MT`, `ND`, `NS`, `NT`, `PD`, `PS`, `PT`, `TD`, `TS`, `TT`, `LT` | `x12TimeCodeZone` |
+ *
+ * - **The narrowing pattern.** With `const classified = classifyX12TimeCode(code)`, the line
+ *   `if (classified?.kind === "offset") x12TimeCodeOffset(classified.timeCode)` compiles with
+ *   no cast: inside the test, `classified.timeCode` is `X12OffsetTimeCode`. The `"zone"` branch
+ *   passes `classified.timeCode` to `x12TimeCodeZone` the same way.
+ * - Both members are always present, and each call returns a new object.
+ * - `GM` ("Greenwich Mean Time") is an offset code: GMT reads it as `+00:00`, as
+ *   `x12TimeCodeOffset` explains.
+ * - `25`–`29` were added in release 006010. The function takes no release, so it reads them.
+ * - This is a time code, not a format qualifier: `TS` here is Atlantic Standard Time. Classify
+ *   a data element 1250 code with `classifyX12DateTimePeriodFormat`.
+ * - Matching is exact: two characters, upper case, no padding.
+ * - Returns `null` for a code that is not one of the 56 and for a non-string. It returns a
+ *   result exactly when `isValidX12TimeCode` is true.
+ *
+ * @param timeCode X12 data element 623 time code, as it arrives (e.g. "20")
+ * @returns `{ kind, timeCode }`, or null on invalid input
+ *
+ * @example classifyX12TimeCode("20") // { kind: "offset", timeCode: "20" }
+ * @example classifyX12TimeCode("UT") // { kind: "offset", timeCode: "UT" }
+ * @example classifyX12TimeCode("GM") // { kind: "offset", timeCode: "GM" }
+ * @example classifyX12TimeCode("ES") // { kind: "zone", timeCode: "ES" }
+ * @example classifyX12TimeCode("ET") // { kind: "zone", timeCode: "ET" }
+ * @example classifyX12TimeCode("LT") // { kind: "zone", timeCode: "LT" }
+ * @example classifyX12TimeCode("EST") // null (not a 623 code)
+ * @example classifyX12TimeCode("et") // null (matching is exact)
+ */
+export function classifyX12TimeCode(timeCode) {
+    // Each reader owns the list of its codes and returns its sentinel for any other value, so a
+    // code is an offset code exactly when the offset reader reads it.
+    if (x12TimeCodeOffset(timeCode) !== "") {
+        return { kind: "offset", timeCode: timeCode };
+    }
+    if (x12TimeCodeZone(timeCode) !== null) {
+        return { kind: "zone", timeCode: timeCode };
+    }
+    return null;
+}

package/dist/intermodal/parse/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./classifyEdifactDtmFormat.js";
+export * from "./classifyX12DateTimePeriodFormat.js";
+export * from "./classifyX12TimeCode.js";
+export * from "./parseEdifactDate.js";
+export * from "./parseEdifactDatePeriod.js";
+export * from "./parseEdifactDateTime.js";
+export * from "./parseEdifactDateTimePeriod.js";
+export * from "./parseEdifactOffsetDateTime.js";
+export * from "./parseEdifactTime.js";
+export * from "./parseEpcisEvent.js";
+export * from "./parseX12Date.js";
+export * from "./parseX12DateAndTime.js";
+export * from "./parseX12DateRange.js";
+export * from "./parseX12DateTime.js";
+export * from "./parseX12DateTimeRange.js";
+export * from "./parseX12Time.js";
+export * from "./x12TimeCodeOffset.js";
+export * from "./x12TimeCodeZone.js";

package/dist/intermodal/parse/index.js

@@ -0,0 +1,18 @@
+export * from "./classifyEdifactDtmFormat.js";
+export * from "./classifyX12DateTimePeriodFormat.js";
+export * from "./classifyX12TimeCode.js";
+export * from "./parseEdifactDate.js";
+export * from "./parseEdifactDatePeriod.js";
+export * from "./parseEdifactDateTime.js";
+export * from "./parseEdifactDateTimePeriod.js";
+export * from "./parseEdifactOffsetDateTime.js";
+export * from "./parseEdifactTime.js";
+export * from "./parseEpcisEvent.js";
+export * from "./parseX12Date.js";
+export * from "./parseX12DateAndTime.js";
+export * from "./parseX12DateRange.js";
+export * from "./parseX12DateTime.js";
+export * from "./parseX12DateTimeRange.js";
+export * from "./parseX12Time.js";
+export * from "./x12TimeCodeOffset.js";
+export * from "./x12TimeCodeZone.js";

package/dist/intermodal/parse/parseEdifactDate.d.ts

@@ -0,0 +1,37 @@
+import type { EdifactDateFormat } from "../../types/edi.js";
+/**
+ * Parse a UN/EDIFACT `DTM` value that states a calendar date, as an ISO 8601 date.
+ *
+ * A `DTM` segment carries its value in data element **2380** and, in data element **2379**, the
+ * format code that says how to read it. This function reads the code whose value is a date. The
+ * mask and description are the UNTDID directory's, read from
+ * [UNECE's D.21B page as archived](http://web.archive.org/web/20240303123657/https://service.unece.org/trade/untdid/d21b/tred/tred2379.htm).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `102` | `CCYYMMDD` | "Calendar date: C = Century ; Y = Year ; M = Month ; D = Day." |
+ *
+ * - The value must be the eight digits of the mask and nothing else: a hyphen, a space or a
+ *   ninth digit returns `""`.
+ * - Fields are checked, not clamped: month 13, 31 June and 29 February 2023 return `""`.
+ * - The year is the four digits as written, `0000` to `9999`.
+ * - A two-digit year (`101`, `YYMMDD`) is not read: UN/EDIFACT does not say which century it
+ *   belongs to. Read one with
+ *   `parseDateWithPattern("240615", "yyMMdd", undefined, { yearWindow: 2000 })`.
+ * - Returns `""` for any other code, a code of another kind included (`203` is read by
+ *   `parseEdifactDateTime`); `classifyEdifactDtmFormat` names the kind of a code. Returns `""`
+ *   for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "20240615")
+ * @param format The data element 2379 format code
+ * @returns the date as `YYYY-MM-DD`, or "" on invalid input
+ *
+ * @example parseEdifactDate("20240615", "102") // "2024-06-15"
+ * @example parseEdifactDate("20240229", "102") // "2024-02-29"
+ * @example parseEdifactDate("20230229", "102") // "" (2023 has no 29 February)
+ * @example parseEdifactDate("2024-06-15", "102") // "" (the value is the digits of the mask)
+ * @example parseEdifactDate("240615", "102") // "" (a two-digit year is not read)
+ * @example parseEdifactDate("202406151430", "203") // "" (a date-time code: use parseEdifactDateTime)
+ */
+export declare function parseEdifactDate(value: string, format: EdifactDateFormat): string;

package/dist/intermodal/parse/parseEdifactDate.js

@@ -0,0 +1,45 @@
+import { readEdiValue } from "../../internal/ediDateTimeFields.js";
+/**
+ * Parse a UN/EDIFACT `DTM` value that states a calendar date, as an ISO 8601 date.
+ *
+ * A `DTM` segment carries its value in data element **2380** and, in data element **2379**, the
+ * format code that says how to read it. This function reads the code whose value is a date. The
+ * mask and description are the UNTDID directory's, read from
+ * [UNECE's D.21B page as archived](http://web.archive.org/web/20240303123657/https://service.unece.org/trade/untdid/d21b/tred/tred2379.htm).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `102` | `CCYYMMDD` | "Calendar date: C = Century ; Y = Year ; M = Month ; D = Day." |
+ *
+ * - The value must be the eight digits of the mask and nothing else: a hyphen, a space or a
+ *   ninth digit returns `""`.
+ * - Fields are checked, not clamped: month 13, 31 June and 29 February 2023 return `""`.
+ * - The year is the four digits as written, `0000` to `9999`.
+ * - A two-digit year (`101`, `YYMMDD`) is not read: UN/EDIFACT does not say which century it
+ *   belongs to. Read one with
+ *   `parseDateWithPattern("240615", "yyMMdd", undefined, { yearWindow: 2000 })`.
+ * - Returns `""` for any other code, a code of another kind included (`203` is read by
+ *   `parseEdifactDateTime`); `classifyEdifactDtmFormat` names the kind of a code. Returns `""`
+ *   for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "20240615")
+ * @param format The data element 2379 format code
+ * @returns the date as `YYYY-MM-DD`, or "" on invalid input
+ *
+ * @example parseEdifactDate("20240615", "102") // "2024-06-15"
+ * @example parseEdifactDate("20240229", "102") // "2024-02-29"
+ * @example parseEdifactDate("20230229", "102") // "" (2023 has no 29 February)
+ * @example parseEdifactDate("2024-06-15", "102") // "" (the value is the digits of the mask)
+ * @example parseEdifactDate("240615", "102") // "" (a two-digit year is not read)
+ * @example parseEdifactDate("202406151430", "203") // "" (a date-time code: use parseEdifactDateTime)
+ */
+export function parseEdifactDate(value, format) {
+    try {
+        return readEdiValue("edifact", "date", format, value);
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile argument is invalid input, not an exception.
+        return "";
+    }
+}

package/dist/intermodal/parse/parseEdifactDatePeriod.d.ts

@@ -0,0 +1,43 @@
+import type { EdiDatePeriod, EdifactDatePeriodFormat } from "../../types/edi.js";
+/**
+ * Parse a UN/EDIFACT `DTM` value that states a period between two calendar dates, as its start
+ * and end.
+ *
+ * A `DTM` segment carries its value in data element **2380** and, in data element **2379**, the
+ * format code that says how to read it. The mask and description are the UNTDID directory's,
+ * read from
+ * [UNECE's D.21B page as archived](http://web.archive.org/web/20240303123657/https://service.unece.org/trade/untdid/d21b/tred/tred2379.htm).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `718` | `CCYYMMDD-CCYYMMDD` | "A period of time specified by giving the start date followed by the end date (both including century). Data is to be transmitted as consecutive characters without hyphen." |
+ *
+ * - **A period is transmitted without a hyphen, and a hyphen is rejected.** Every directory
+ *   read (twelve, from D.93A to D.22B) says so; the hyphen in the mask is notation.
+ *   `"2024061520240620"` reads and `"20240615-20240620"` returns `null`.
+ * - **`start` and `end` are the two dates as transmitted**, each `YYYY-MM-DD`. The directory
+ *   does not say whether the end date is inside the period: that is the message's to define, so
+ *   no day is added or removed. Pass the pair to the plain interval functions as `(start, end)`,
+ *   for example `intervalLengthDate(period.start, period.end, "days")`; they leave `end`
+ *   outside the interval.
+ * - **An end before its start returns `null`**: a reversed period names no span of time. An end
+ *   equal to its start is a valid period.
+ * - Fields are checked, not clamped: month 13, 31 June and 29 February 2023 return `null`.
+ * - A two-digit year (`717`, `YYMMDD-YYMMDD`) is not read. Split such a value in two and read
+ *   each half with `parseDateWithPattern`, a `yy` pattern and its `yearWindow` option.
+ * - Returns `null` for any other code, a code of another kind included (`719` is read by
+ *   `parseEdifactDateTimePeriod`), and for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "2024061520240620")
+ * @param format The data element 2379 format code
+ * @returns `{ start, end }`, two ISO 8601 dates, or null on invalid input
+ *
+ * @example parseEdifactDatePeriod("2024061520240620", "718") // { start: "2024-06-15", end: "2024-06-20" }
+ * @example parseEdifactDatePeriod("2024061520240615", "718") // { start: "2024-06-15", end: "2024-06-15" }
+ * @example parseEdifactDatePeriod("20240615-20240620", "718") // null (a period is transmitted without a hyphen)
+ * @example parseEdifactDatePeriod("2024062020240615", "718") // null (the end precedes the start)
+ * @example parseEdifactDatePeriod("2023022920240620", "718") // null (2023 has no 29 February)
+ * @example parseEdifactDatePeriod("20240615", "102") // null (a date code: use parseEdifactDate)
+ */
+export declare function parseEdifactDatePeriod(value: string, format: EdifactDatePeriodFormat): EdiDatePeriod | null;

package/dist/intermodal/parse/parseEdifactDatePeriod.js

@@ -0,0 +1,51 @@
+import { readEdiRange } from "../../internal/ediDateTimeFields.js";
+/**
+ * Parse a UN/EDIFACT `DTM` value that states a period between two calendar dates, as its start
+ * and end.
+ *
+ * A `DTM` segment carries its value in data element **2380** and, in data element **2379**, the
+ * format code that says how to read it. The mask and description are the UNTDID directory's,
+ * read from
+ * [UNECE's D.21B page as archived](http://web.archive.org/web/20240303123657/https://service.unece.org/trade/untdid/d21b/tred/tred2379.htm).
+ *
+ * ### Format code
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `718` | `CCYYMMDD-CCYYMMDD` | "A period of time specified by giving the start date followed by the end date (both including century). Data is to be transmitted as consecutive characters without hyphen." |
+ *
+ * - **A period is transmitted without a hyphen, and a hyphen is rejected.** Every directory
+ *   read (twelve, from D.93A to D.22B) says so; the hyphen in the mask is notation.
+ *   `"2024061520240620"` reads and `"20240615-20240620"` returns `null`.
+ * - **`start` and `end` are the two dates as transmitted**, each `YYYY-MM-DD`. The directory
+ *   does not say whether the end date is inside the period: that is the message's to define, so
+ *   no day is added or removed. Pass the pair to the plain interval functions as `(start, end)`,
+ *   for example `intervalLengthDate(period.start, period.end, "days")`; they leave `end`
+ *   outside the interval.
+ * - **An end before its start returns `null`**: a reversed period names no span of time. An end
+ *   equal to its start is a valid period.
+ * - Fields are checked, not clamped: month 13, 31 June and 29 February 2023 return `null`.
+ * - A two-digit year (`717`, `YYMMDD-YYMMDD`) is not read. Split such a value in two and read
+ *   each half with `parseDateWithPattern`, a `yy` pattern and its `yearWindow` option.
+ * - Returns `null` for any other code, a code of another kind included (`719` is read by
+ *   `parseEdifactDateTimePeriod`), and for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "2024061520240620")
+ * @param format The data element 2379 format code
+ * @returns `{ start, end }`, two ISO 8601 dates, or null on invalid input
+ *
+ * @example parseEdifactDatePeriod("2024061520240620", "718") // { start: "2024-06-15", end: "2024-06-20" }
+ * @example parseEdifactDatePeriod("2024061520240615", "718") // { start: "2024-06-15", end: "2024-06-15" }
+ * @example parseEdifactDatePeriod("20240615-20240620", "718") // null (a period is transmitted without a hyphen)
+ * @example parseEdifactDatePeriod("2024062020240615", "718") // null (the end precedes the start)
+ * @example parseEdifactDatePeriod("2023022920240620", "718") // null (2023 has no 29 February)
+ * @example parseEdifactDatePeriod("20240615", "102") // null (a date code: use parseEdifactDate)
+ */
+export function parseEdifactDatePeriod(value, format) {
+    try {
+        return readEdiRange("edifact", "datePeriod", format, value);
+    }
+    catch {
+        // Never throws (Core Rule 3): a hostile argument is invalid input, not an exception.
+        return null;
+    }
+}

package/dist/intermodal/parse/parseEdifactDateTime.d.ts

@@ -0,0 +1,43 @@
+import type { EdifactDateTimeFormat } from "../../types/edi.js";
+/**
+ * Parse a UN/EDIFACT `DTM` value that states a date and a time with no offset, as an ISO 8601
+ * local date-time.
+ *
+ * A `DTM` segment carries its value in data element **2380** and, in data element **2379**, the
+ * format code that says how to read it. This function reads the codes whose value is a wall
+ * clock at a place the value does not name. Masks and descriptions are the UNTDID directory's,
+ * read from
+ * [UNECE's D.21B page as archived](http://web.archive.org/web/20240303123657/https://service.unece.org/trade/untdid/d21b/tred/tred2379.htm).
+ *
+ * ### Format codes
+ * | Code | Mask | The directory's description |
+ * |---|---|---|
+ * | `203` | `CCYYMMDDHHMM` | "Calendar date including time with minutes" |
+ * | `204` | `CCYYMMDDHHMMSS` | "Calendar date including time with seconds" |
+ *
+ * - **The result is local, never UTC.** It carries no `Z` and no offset: reading a `203` value
+ *   as UTC is the most common EDI timestamp bug. Pass the result and the place's IANA zone to
+ *   `resolveLocal` to get the instant.
+ * - The value must be the digits of its code's mask: `"202406151430"` is a `203` value and not
+ *   a `204` one.
+ * - Seconds are always written in the result, `00` for `203`.
+ * - Fields are checked, not clamped: hour 24, second 60, 31 June and 29 February 2023 return
+ *   `""`.
+ * - A two-digit year (`201`, `202`) is not read: UN/EDIFACT does not say which century it
+ *   belongs to. Read one with
+ *   `parseDateTimeWithPattern("2406151430", "yyMMddHHmm", undefined, { yearWindow: 2000 })`.
+ * - Returns `""` for any other code, a code of another kind included (`205` is read by
+ *   `parseEdifactOffsetDateTime`), and for a non-string argument.
+ *
+ * @param value The data element 2380 value (e.g. "202406151430")
+ * @param format The data element 2379 format code
+ * @returns the local date-time as `YYYY-MM-DDTHH:MM:SS`, or "" on invalid input
+ *
+ * @example parseEdifactDateTime("202406151430", "203") // "2024-06-15T14:30:00"
+ * @example parseEdifactDateTime("20240615143045", "204") // "2024-06-15T14:30:45"
+ * @example parseEdifactDateTime("202406151430", "204") // "" (twelve digits is a 203 value)
+ * @example parseEdifactDateTime("202302291430", "203") // "" (2023 has no 29 February)
+ * @example parseEdifactDateTime("202406152430", "203") // "" (hour 24)
+ * @example parseEdifactDateTime("202406151430+0200", "205") // "" (an offset code: use parseEdifactOffsetDateTime)
+ */
+export declare function parseEdifactDateTime(value: string, format: EdifactDateTimeFormat): string;