@jd-data-limited/easy-fm 4.1.15 → 5.0.0-beta.2

package/dist/records/portalBase.d.ts

@@ -1,7 +1,6 @@
-import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type RecordBase } from './recordBase.js';
 import { type LayoutRecord } from './layoutRecord.js';
-import { type LayoutInterface } from '../layouts/layoutInterface.js';
+import { type LayoutInterface, RecordFieldsMap } from '../layouts/layoutInterface.js';
 export interface PortalBase<T extends RecordFieldsMap> {
     readonly record: LayoutRecord<LayoutInterface>;
     readonly name: string;

package/dist/records/portalRecord.d.ts

@@ -1,8 +1,10 @@
 import { RecordBase } from './recordBase.js';
 import { type extraBodyOptions, RecordTypes } from '../types.js';
-import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type PortalBase } from './portalBase.js';
-import { type Field, type FieldValue } from './field.js';
+import z from "zod";
+import { ApiFieldMetadata } from "../models/apiResults.js";
+import { RecordFieldsMap } from "../layouts/layoutInterface.js";
+import { Field } from "./fields/field.js";
 /**
  * Represents a PortalRecord, which is a record in a portal within a parent record.
  * @template T - The type of the record's field map.
@@ -18,8 +20,9 @@ export declare class PortalRecord<T extends RecordFieldsMap> extends RecordBase<
      * @param {extraBodyOptions} [extraBody={}] - The optional extra body options.
      * @returns {Promise} - A promise that resolves when the record is committed.
      */
-    commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<import("../index.js").LayoutInterface>>;
-    toObject(fieldFilter: (a: Field<FieldValue>) => boolean): {
+    commit(extraBody?: extraBodyOptions): Promise<import("./layoutRecord.js").LayoutRecord<import("../layouts/layoutInterface.js").LayoutInterface>>;
+    getFieldMetadata(fieldId: string): z.infer<typeof ApiFieldMetadata>;
+    toObject(fieldFilter: (a: Field) => boolean): {
         modId?: string;
         recordId?: string;
     } & Record<string, string>;

package/dist/records/portalRecord.js

@@ -27,6 +27,18 @@ export class PortalRecord extends RecordBase {
     async commit(extraBody = {}) {
         return await this.portal.record.commit(extraBody);
     }
+    getFieldMetadata(fieldId) {
+        if (!this.layout.metadata) {
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        }
+        const portalMetadata = this.portal
+            ? this.layout.metadata.portalMetaData[this.portal.name] ?? []
+            : Object.values(this.layout.metadata.portalMetaData).flat();
+        const result = portalMetadata.find(i => i.name === fieldId);
+        if (!result)
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        return result;
+    }
     toObject(fieldFilter) {
         const res = {
             recordId: this.recordId === -1 ? undefined : this.recordId.toString(),

package/dist/records/recordBase.d.ts

@@ -1,9 +1,10 @@
 import { EventEmitter } from 'events';
 import { RecordTypes } from '../types.js';
-import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';
-import { type ApiFieldData } from '../models/apiResults.js';
-import { Field, type FieldValue } from './field.js';
+import { type ApiFieldData, type ApiFieldMetadata } from '../models/apiResults.js';
+import { type z } from 'zod';
+import { RecordFieldsMap } from "../layouts/layoutInterface.js";
+import { Field } from "./fields/field.js";
 export declare abstract class RecordBase<T extends RecordFieldsMap> extends EventEmitter {
     readonly layout: LayoutBase;
     readonly type: RecordTypes;
@@ -16,7 +17,7 @@ export declare abstract class RecordBase<T extends RecordFieldsMap> extends Even
      */
     fields: T;
     protected portalData: any[];
-    protected constructor(layout: LayoutBase, recordId: number, modId: number | undefined, fieldData: ApiFieldData);
+    protected constructor(layout: LayoutBase, recordId: number, modId: number | undefined, fieldData: z.infer<typeof ApiFieldData>);
     get endpoint(): string;
     /**
      * A boolean indicating whether this record has been modified and should be committed
@@ -24,7 +25,8 @@ export declare abstract class RecordBase<T extends RecordFieldsMap> extends Even
      * @returns {boolean} A boolean value indicating whether any of the fields have been edited.
      */
     get edited(): boolean;
-    get fieldsArray(): Array<Field<FieldValue>>;
-    protected processFieldData(fieldData: ApiFieldData): T;
+    get fieldsArray(): Array<Field>;
+    abstract getFieldMetadata(fieldId: string): z.infer<typeof ApiFieldMetadata>;
+    protected processFieldData(fieldData: z.infer<typeof ApiFieldData>): T;
     _onSave(): void;
 }

package/dist/records/recordBase.js

@@ -2,9 +2,9 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 import { EventEmitter } from 'events';
-import * as moment from 'moment';
 import { RecordTypes } from '../types.js';
-import { Field } from './field.js';
+import { DateField, NumberField, TextField, TimeField, TimeStampField, ValueFieldBase } from "./fields/valueField.js";
+import { ContainerField } from "./fields/containerField.js";
 export class RecordBase extends EventEmitter {
     layout;
     type = RecordTypes.UNKNOWN;
@@ -33,49 +33,48 @@ export class RecordBase extends EventEmitter {
      * @returns {boolean} A boolean value indicating whether any of the fields have been edited.
      */
     get edited() {
-        return !!this.fieldsArray.find(i => i.edited);
+        return !!this.fieldsArray.find(i => i instanceof ValueFieldBase && i.edited);
     }
     get fieldsArray() {
         return Object.values(this.fields);
     }
     processFieldData(fieldData) {
         const fields = {};
-        for (const key of Object.keys(fieldData)) {
-            const _field = new Field(this, key, fieldData[key]);
-            if (fieldData[key]) {
-                if (_field.metadata.result === 'timeStamp') {
-                    let date = moment.default(fieldData[key]);
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local();
-                    _field.set(date);
-                    _field.updateOriginalContents();
-                }
-                else if (_field.metadata.result === 'time') {
-                    let date = moment.default(fieldData[key]);
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local();
-                    _field.set(date);
-                    _field.updateOriginalContents();
-                }
-                else if (_field.metadata.result === 'date') {
-                    let date = moment.default(fieldData[key]);
-                    date = date
-                        .utcOffset(this.layout.database.host.timezoneOffsetFunc(date), true)
-                        .local();
-                    _field.set(date);
-                    _field.updateOriginalContents();
-                }
+        for (const [key, value] of Object.entries(fieldData)) {
+            const fieldMeta = this.getFieldMetadata(key);
+            let field;
+            switch (fieldMeta.result) {
+                case "text":
+                    field = new TextField(this, key, value);
+                    break;
+                case "number":
+                    field = new NumberField(this, key, value);
+                    break;
+                case "container":
+                    field = new ContainerField(this, key, value);
+                    break;
+                case "timeStamp":
+                    field = new TimeStampField(this, key, value);
+                    break;
+                case "time":
+                    field = new TimeField(this, key, value);
+                    break;
+                case "date":
+                    field = new DateField(this, key, value);
+                    break;
+                default:
+                    throw new Error(`Attempted to parse unknown field type: ${fieldMeta.result}`);
             }
-            fields[key] = _field;
+            fields[key] = field;
         }
         this.fields = fields;
         return fields;
     }
     _onSave() {
         this.emit('saved');
-        for (const field of this.fieldsArray)
-            field.updateOriginalContents();
+        for (const field of this.fieldsArray) {
+            if (field instanceof ValueFieldBase)
+                field.updateOriginalContents();
+        }
     }
 }

package/dist/types.d.ts

@@ -1,24 +1,29 @@
 import type * as http from 'http';
 import { type FMError } from './FMError.js';
 import { type LayoutInterface } from './layouts/layoutInterface.js';
-export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends string | number | symbol = ''> = Omit<LAYOUT, 'portals'> & {
+import z from "zod";
+export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends keyof LAYOUT['portals'] = never> = Omit<LAYOUT, 'portals'> & {
     portals: Pick<LAYOUT['portals'], PORTALS>;
 };
-export interface databaseOptionsBase {
+/** Shared database connection options. */
+export interface databaseOptionsBase<CREDENTAILS = loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken> {
     database: string;
     debug?: boolean;
-    credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken;
+    credentials: CREDENTAILS;
 }
-export interface databaseOptionsWithExternalSources extends databaseOptionsBase {
+/** Database options including any external FileMaker sources. */
+export interface databaseOptionsWithExternalSources<CREDENTIALS = loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken> extends databaseOptionsBase<CREDENTIALS> {
     database: string;
     debug?: boolean;
-    credentials: loginOptionsOAuth | loginOptionsFileMaker | loginOptionsClaris | loginOptionsToken;
-    externalSources: databaseOptionsBase[];
+    credentials: CREDENTIALS;
+    externalSources: Array<databaseOptionsBase<loginOptionsFileMaker>>;
 }
+/** Use an existing FileMaker Data API token. */
 export interface loginOptionsToken {
     method: 'token';
     token: string;
 }
+/** Use FileMaker Data API OAuth headers to create session. */
 export interface loginOptionsOAuth {
     method: 'oauth';
     oauth: {
@@ -26,27 +31,36 @@ export interface loginOptionsOAuth {
         requestIdentifier: string;
     };
 }
+/** Use standard FileMaker username/password login. */
 export interface loginOptionsFileMaker {
     method: 'filemaker';
     username: string;
     password: string;
+    /**
+     * sessionPoolSize - The maximum number of sessions to keep open in the pool. Default is 4.
+     */
+    sessionPoolSize?: number;
 }
+/** Use Claris authentication for session creation. */
 export interface loginOptionsClaris {
     method: 'claris';
     claris: {
         fmid: string;
     };
 }
+/** Portal fetch paging options for one portal. */
 export interface portalFetchData<T = string> {
     portalName: T;
     offset: number;
     limit: number;
 }
+/** FileMaker scripts to run before, during, or after request processing. */
 export interface ScriptRequestData {
     prerequest?: Script;
     presort?: Script;
     after?: Script;
 }
+/** Additional body options accepted by write operations. */
 export interface extraBodyOptions {
     scripts?: ScriptRequestData;
     options?: {
@@ -68,10 +82,12 @@ export interface extraBodyOptions {
         recordId: number;
     }>;
 }
+/** Simple script reference with optional parameter. */
 export interface Script {
     name: string;
     parameter: string;
 }
+/** Raw record payload shape returned by FileMaker Data API. */
 export interface recordObject {
     recordId: number;
     modId: number;
@@ -79,6 +95,7 @@ export interface recordObject {
     portalData?: portalDataObject;
 }
 export type portalDataObject = Record<string, recordObject>;
+/** Field metadata returned by layout metadata endpoint. */
 export interface FieldMetaData {
     name: string;
     type: string;
@@ -95,38 +112,45 @@ export interface FieldMetaData {
     repetitionStart: number;
     repetitionEnd: number;
 }
+/** Layout metadata for top-level fields and portals. */
 export interface LayoutMetaData {
     fieldMetaData: FieldMetaData[];
     portalMetaData?: Record<string, FieldMetaData[]>;
 }
-export interface FMHostMetadata {
-    productInfo: {
-        buildDate: Date;
-        name: string;
-        version: string;
-        dateFormat: string;
-        timeFormat: string;
-        timeStampFormat: string;
-    };
-}
+/** FileMaker host metadata returned by `/productInfo`. */
+export declare const FMHostMetadata: z.ZodObject<{
+    productInfo: z.ZodObject<{
+        buildDate: z.ZodOptional<z.z.ZodCoercedDate<unknown>>;
+        name: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        dateFormat: z.ZodString;
+        timeFormat: z.ZodString;
+        timeStampFormat: z.ZodString;
+    }, z.z.core.$strip>;
+}, z.z.core.$strip>;
+/** Result returned when a script executes through API call. */
 export interface ScriptResult {
     scriptError?: FMError;
     scriptResult?: string;
 }
+/** Container download result with payload and response metadata. */
 export interface ContainerBufferResult {
     buffer: Buffer;
     mime?: string;
     request: http.IncomingMessage;
 }
-export interface AuthorizationHeaders {
+/** Standard JSON request headers with bearer authorization. */
+export interface AuthorizationHeaders extends Record<string, string> {
     'Content-Type': 'application/json';
     Authorization: string;
 }
-export interface AuthorizationHeadersOAuth {
+/** OAuth request headers required by FileMaker Data API. */
+export interface AuthorizationHeadersOAuth extends Record<string, string> {
     'Content-Type': 'application/json';
     'X-FM-Data-OAuth-RequestId': string;
     'X-FM-Data-OAuth-Identifier': string;
 }
+/** Options used when creating empty record shells. */
 export interface RecordFetchOptions {
     readonly portals: readonly string[];
 }

package/dist/types.js

@@ -1,6 +1,18 @@
 /*
  * Copyright (c) 2022-2024. See LICENSE file for more information
  */
+import z from "zod";
+/** FileMaker host metadata returned by `/productInfo`. */
+export const FMHostMetadata = z.object({
+    productInfo: z.object({
+        buildDate: z.coerce.date().optional(),
+        name: z.string(),
+        version: z.string().optional(),
+        dateFormat: z.string(),
+        timeFormat: z.string(),
+        timeStampFormat: z.string()
+    })
+});
 export var RecordTypes;
 (function (RecordTypes) {
     RecordTypes[RecordTypes["UNKNOWN"] = 0] = "UNKNOWN";

package/dist/utils/addHeaders.d.ts

@@ -0,0 +1,5 @@
+/**
+ * addHeaders adds headers to the inputted request header object
+ * @param headers
+ */
+export declare function addHeaders(req: RequestInit, headers: Record<string, string>): void;

package/dist/utils/addHeaders.js

@@ -0,0 +1,24 @@
+/**
+ * addHeaders adds headers to the inputted request header object
+ * @param headers
+ */
+export function addHeaders(req, headers) {
+    if (!req.headers) {
+        req.headers = headers;
+    }
+    else if (req.headers instanceof Headers) {
+        for (const key of Object.keys(headers)) {
+            req.headers.set(key, headers[key]);
+        }
+    }
+    else if (Array.isArray(req.headers)) {
+        for (const [key, value] of Object.entries(headers)) {
+            req.headers.push([key, value]);
+        }
+    }
+    else {
+        for (const key of Object.keys(headers)) {
+            req.headers[key] = headers[key];
+        }
+    }
+}

package/dist/utils/query.d.ts

@@ -1,16 +1,32 @@
-import { type Moment } from 'moment';
+import { Temporal } from 'temporal-polyfill';
 export declare const FindRequestSymbol: unique symbol;
-export interface TimestampType {
-    type: 'date' | 'time' | 'timestamp';
-    moment: Moment;
-}
+export type TimestampType = Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime;
 type QueryParameter = string | number | TimestampType;
+/** Represents a FileMaker find value produced by `query(...)`. */
 export interface Query {
     [FindRequestSymbol]: Array<string | TimestampType>;
 }
+type LegacyDateLike = {
+    toDate: () => Date;
+};
+type DateInput = Date | LegacyDateLike;
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal date.
+ * @deprecated Construct a `Temporal.PlainDate` directly instead.
+ */
+export declare function asDate(value: DateInput | Temporal.PlainDate | Temporal.PlainDateTime): Temporal.PlainDate;
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal time.
+ * @deprecated Construct a `Temporal.PlainTime` directly instead.
+ */
+export declare function asTime(value: DateInput | Temporal.PlainTime | Temporal.PlainDateTime): Temporal.PlainTime;
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal timestamp.
+ * @deprecated Construct a `Temporal.PlainDateTime` directly instead.
+ */
+export declare function asTimestamp(value: DateInput | Temporal.PlainDateTime): Temporal.PlainDateTime;
+/** Escapes special characters in a raw FileMaker find string. */
 export declare function queryEscape(str: string): string;
+/** Builds a FileMaker find value using template-string syntax. */
 export declare function query(strings: TemplateStringsArray, ...args: QueryParameter[]): Query;
-export declare function asDate(date: Date | Moment): TimestampType;
-export declare function asTime(date: Date | Moment): TimestampType;
-export declare function asTimestamp(date: Date | Moment): TimestampType;
 export {};

package/dist/utils/query.js

@@ -1,15 +1,74 @@
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
-import moment from 'moment';
+import { Temporal } from 'temporal-polyfill';
 export const FindRequestSymbol = Symbol('easyfm-findrequest');
 const SPECIAL_CHARACTERS = ['\\', '=', '<', '≤', '≥', '>', '…', '...', '//', '@', '#', '*', '"', '~'];
+function toDate(value) {
+    const date = value instanceof Date ? value : value.toDate();
+    if (Number.isNaN(date.getTime()))
+        throw new RangeError('Invalid date value');
+    return date;
+}
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal date.
+ * @deprecated Construct a `Temporal.PlainDate` directly instead.
+ */
+export function asDate(value) {
+    if (value instanceof Temporal.PlainDate)
+        return value;
+    if (value instanceof Temporal.PlainDateTime)
+        return value.toPlainDate();
+    const date = toDate(value);
+    return Temporal.PlainDate.from({
+        year: date.getFullYear(),
+        month: date.getMonth() + 1,
+        day: date.getDate()
+    });
+}
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal time.
+ * @deprecated Construct a `Temporal.PlainTime` directly instead.
+ */
+export function asTime(value) {
+    if (value instanceof Temporal.PlainTime)
+        return value;
+    if (value instanceof Temporal.PlainDateTime)
+        return value.toPlainTime();
+    const date = toDate(value);
+    return Temporal.PlainTime.from({
+        hour: date.getHours(),
+        minute: date.getMinutes(),
+        second: date.getSeconds(),
+        millisecond: date.getMilliseconds()
+    });
+}
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal timestamp.
+ * @deprecated Construct a `Temporal.PlainDateTime` directly instead.
+ */
+export function asTimestamp(value) {
+    if (value instanceof Temporal.PlainDateTime)
+        return value;
+    const date = toDate(value);
+    return Temporal.PlainDateTime.from({
+        year: date.getFullYear(),
+        month: date.getMonth() + 1,
+        day: date.getDate(),
+        hour: date.getHours(),
+        minute: date.getMinutes(),
+        second: date.getSeconds(),
+        millisecond: date.getMilliseconds()
+    });
+}
+/** Escapes special characters in a raw FileMaker find string. */
 export function queryEscape(str) {
     for (const char of SPECIAL_CHARACTERS) {
         str = str.replace(char, `\\${char}`);
     }
     return str;
 }
+/** Builds a FileMaker find value using template-string syntax. */
 export function query(strings, ...args) {
     const argStrings = args.map(item => {
         if (typeof item === 'number') {
@@ -26,22 +85,3 @@ export function query(strings, ...args) {
     }).flat(1);
     return { [FindRequestSymbol]: query };
 }
-export function asDate(date) {
-    return {
-        type: 'date',
-        moment: moment(date)
-    };
-}
-export function asTime(date) {
-    return {
-        type: 'time',
-        moment: moment(date)
-    };
-}
-export function asTimestamp(date) {
-    return {
-        type: 'timestamp',
-        moment: moment(date)
-    };
-}
-query;

package/dist/utils/temporal.d.ts

@@ -0,0 +1,9 @@
+import { Temporal } from 'temporal-polyfill';
+export type TemporalValue = Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime;
+export type TemporalValueType = 'date' | 'time' | 'timestamp';
+/** Formats a Temporal value using the supplied token-based format. */
+export declare function temporalToString(value: TemporalValue, format: string): string;
+export declare function stringToTemporal(value: string, type: 'date', format: string): Temporal.PlainDate;
+export declare function stringToTemporal(value: string, type: 'time', format: string): Temporal.PlainTime;
+export declare function stringToTemporal(value: string, type: 'timestamp', format: string): Temporal.PlainDateTime;
+export declare function stringToTemporal(value: string, type: TemporalValueType, format: string): TemporalValue;

package/dist/utils/temporal.js

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2023-2024. See LICENSE file for more information
+ */
+import { Temporal } from 'temporal-polyfill';
+const FORMAT_TOKEN_PATTERN = /yyyy|MM|dd|HH|mm|ss/g;
+const TOKEN_PATTERNS = {
+    yyyy: '\\d{4}',
+    MM: '\\d{2}',
+    dd: '\\d{2}',
+    HH: '\\d{2}',
+    mm: '\\d{2}',
+    ss: '\\d{2}'
+};
+function normalizeFormat(format) {
+    return format.replace(/YYYY/g, 'yyyy').replace(/DD/g, 'dd');
+}
+function pad(value, length = 2) {
+    return value.toString().padStart(length, '0');
+}
+function invalidTemporalString(value, format) {
+    throw new RangeError(`Invalid Temporal value ${JSON.stringify(value)}; expected ${format}`);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function tokensIn(format) {
+    const tokens = format.match(FORMAT_TOKEN_PATTERN);
+    if (!tokens)
+        throw new RangeError(`Format ${JSON.stringify(format)} contains no supported tokens`);
+    if (new Set(tokens).size !== tokens.length) {
+        throw new RangeError(`Format ${JSON.stringify(format)} contains duplicate tokens`);
+    }
+    return tokens;
+}
+function parserFor(format) {
+    const tokens = tokensIn(format);
+    let source = '^';
+    let lastIndex = 0;
+    for (const match of format.matchAll(FORMAT_TOKEN_PATTERN)) {
+        source += escapeRegExp(format.slice(lastIndex, match.index));
+        source += `(${TOKEN_PATTERNS[match[0]]})`;
+        lastIndex = match.index + match[0].length;
+    }
+    source += `${escapeRegExp(format.slice(lastIndex))}$`;
+    return { pattern: new RegExp(source), tokens };
+}
+/** Formats a Temporal value using the supplied token-based format. */
+export function temporalToString(value, format) {
+    format = normalizeFormat(format);
+    const values = {};
+    if (value instanceof Temporal.PlainDateTime) {
+        Object.assign(values, {
+            yyyy: pad(value.year, 4), MM: pad(value.month), dd: pad(value.day),
+            HH: pad(value.hour), mm: pad(value.minute), ss: pad(value.second)
+        });
+    }
+    else if (value instanceof Temporal.PlainDate) {
+        Object.assign(values, { yyyy: pad(value.year, 4), MM: pad(value.month), dd: pad(value.day) });
+    }
+    else if (value instanceof Temporal.PlainTime) {
+        Object.assign(values, { HH: pad(value.hour), mm: pad(value.minute), ss: pad(value.second) });
+    }
+    else {
+        throw new TypeError('Expected a Temporal.PlainDate, Temporal.PlainTime, or Temporal.PlainDateTime');
+    }
+    tokensIn(format).forEach(token => {
+        if (values[token] === undefined)
+            throw new RangeError(`Token ${token} is not available for this Temporal type`);
+    });
+    return format.replace(FORMAT_TOKEN_PATTERN, token => values[token]);
+}
+/** Parses a Temporal value using the supplied token-based format. */
+export function stringToTemporal(value, type, format) {
+    format = normalizeFormat(format);
+    const { pattern, tokens } = parserFor(format);
+    const match = pattern.exec(value);
+    if (!match)
+        return invalidTemporalString(value, format);
+    const parts = Object.fromEntries(tokens.map((token, index) => [token, Number(match[index + 1])]));
+    const required = type === 'date'
+        ? ['yyyy', 'MM', 'dd']
+        : type === 'time'
+            ? ['HH', 'mm', 'ss']
+            : ['yyyy', 'MM', 'dd', 'HH', 'mm', 'ss'];
+    if (tokens.length !== required.length || required.some(token => parts[token] === undefined)) {
+        throw new RangeError(`Format ${JSON.stringify(format)} does not match Temporal type ${type}`);
+    }
+    if (type === 'date') {
+        return Temporal.PlainDate.from({
+            year: parts.yyyy,
+            month: parts.MM,
+            day: parts.dd
+        }, { overflow: 'reject' });
+    }
+    else if (type === 'time') {
+        return Temporal.PlainTime.from({
+            hour: parts.HH,
+            minute: parts.mm,
+            second: parts.ss
+        }, { overflow: 'reject' });
+    }
+    return Temporal.PlainDateTime.from({
+        year: parts.yyyy,
+        month: parts.MM,
+        day: parts.dd,
+        hour: parts.HH,
+        minute: parts.mm,
+        second: parts.ss
+    }, { overflow: 'reject' });
+}