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

package/dist/records/layoutRecord.d.ts

@@ -4,14 +4,14 @@ import { PortalRecord } from './portalRecord.js';
 import { Portal } from './portal.js';
 import { type LayoutInterface } from '../layouts/layoutInterface.js';
 import { type LayoutRecordBase } from './layoutRecordBase.js';
-import { type ApiPortalData, type ApiRowDataDef } from '../models/apiResults.js';
+import { type ApiFieldData, ApiFieldMetadata, type ApiPortalData, type ApiRowDataDef } from '../models/apiResults.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';
-import { type Field, type FieldValue } from './field.js';
 import z from 'zod';
+import { Field } from "./fields/field.js";
 export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT['fields']> implements LayoutRecordBase {
     portals: LAYOUT['portals'];
     private readonly portalsToInclude;
-    constructor(layout: LayoutBase, recordId: number | string, modId?: string | number, fieldData?: Record<string, string | number>, portalData?: z.infer<typeof ApiPortalData> | null, portalsToInclude?: Array<keyof LAYOUT['portals']>);
+    constructor(layout: LayoutBase, recordId: number | string, modId?: string | number, fieldData?: z.infer<typeof ApiFieldData>, portalData?: z.infer<typeof ApiPortalData> | null, portalsToInclude?: Array<keyof LAYOUT['portals']>);
     /** Returns all loaded portals on this record as an array. */
     get portalsArray(): Array<Portal<any>>;
     /**
@@ -21,6 +21,7 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
      * @throws {FMError} - If an error occurs during the commit process.
      */
     commit(extraBody?: extraBodyOptions): Promise<this>;
+    getFieldMetadata(fieldId: string): z.infer<typeof ApiFieldMetadata>;
     protected processPortalData(portalData: z.infer<typeof ApiPortalData>): void;
     /**
      * Reloads this record from FileMaker.
@@ -36,11 +37,11 @@ export declare class LayoutRecord<LAYOUT extends LayoutInterface> extends Record
     /** Deletes this record from FileMaker. */
     delete(): Promise<void>;
     /** Returns this record's edited fields as a FileMaker API payload. */
-    fieldsToObject(filter?: (a: Field<FieldValue>) => boolean): Omit<z.infer<typeof ApiRowDataDef>, 'portalData'>;
+    fieldsToObject(filter?: (a: Field) => boolean): Omit<z.infer<typeof ApiRowDataDef>, 'portalData'>;
     /** Returns this record and its portal edits as a FileMaker API payload. */
-    toObject(filter?: (a: Field<FieldValue>) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<any>) => any, portalFieldFilter?: (a: Field<FieldValue>) => any): {
-        fieldData: Record<string, string | number>;
-        portalData: Record<string, Record<string, string | number>[]>;
+    toObject(filter?: (a: Field) => any, portalFilter?: (a: Portal<any>) => any, portalRowFilter?: (a: PortalRecord<any>) => any, portalFieldFilter?: (a: Field) => any): {
+        fieldData: Record<string, string | number | null>;
+        portalData: Record<string, Record<string, string | number | null>[]>;
         modId: string;
         recordId: string;
         portalDataInfo?: {

package/dist/records/layoutRecord.js

@@ -6,8 +6,8 @@ import { PortalRecord } from './portalRecord.js';
 import { Portal } from './portal.js';
 import { FMError } from '../FMError.js';
 import { ApiRecordResponseObj } from '../models/apiResults.js';
-import moment from 'moment';
 import z from 'zod';
+import { ValueFieldBase } from "./fields/valueField.js";
 export class LayoutRecord extends RecordBase {
     portals = {};
     portalsToInclude;
@@ -67,6 +67,7 @@ export class LayoutRecord extends RecordBase {
             }
             this.recordId = parseInt(res.recordId);
             this.modId = parseInt(res.modId);
+            this._onSave();
             return this;
         }
         // for (let item of Object.keys(data)) extraBody[item] = data[item]
@@ -90,6 +91,15 @@ export class LayoutRecord extends RecordBase {
         this._onSave();
         return this;
     }
+    getFieldMetadata(fieldId) {
+        if (!this.layout.metadata) {
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        }
+        let result = this.layout.metadata.fieldMetaData.find(i => i.name === fieldId);
+        if (!result)
+            throw new Error("Field metadata not found. Ensure you run layout.getLayoutMeta() first.");
+        return result;
+    }
     processPortalData(portalData) {
         for (const portalName of Object.keys(portalData)) {
             const _portal = new Portal(this, portalName);
@@ -161,37 +171,19 @@ export class LayoutRecord extends RecordBase {
         this.emit('deleted');
     }
     /** Returns this record's edited fields as a FileMaker API payload. */
-    fieldsToObject(filter = (a) => a.edited) {
+    fieldsToObject(filter = (a) => a instanceof ValueFieldBase && a.edited) {
         const fieldsProcessed = {};
-        let field;
-        for (field of this.fieldsArray.filter(field => filter(field))) {
-            let value = field.value;
-            if (value instanceof Date) {
-                let _value = moment(value);
-                _value = _value
-                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value));
-                switch (field.metadata.result) {
-                    case 'time':
-                        value = _value.format(this.layout.database.host.timeFormat);
-                        break;
-                    case 'date':
-                        value = _value.format(this.layout.database.host.dateFormat);
-                        break;
-                    default:
-                        value = _value.format(this.layout.database.host.timeStampFormat);
-                }
-            }
-            fieldsProcessed[field.id] = value;
+        for (const field of this.fieldsArray.filter(field => filter(field))) {
+            fieldsProcessed[field.id] = field.serializeRawValue();
         }
-        const obj = {
+        return {
             recordId: this.recordId.toString(),
             modId: this.modId.toString(),
             fieldData: fieldsProcessed
         };
-        return obj;
     }
     /** Returns this record and its portal edits as a FileMaker API payload. */
-    toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
+    toObject(filter = (a) => a instanceof ValueFieldBase && a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a instanceof ValueFieldBase && a.edited) {
         const obj = {
             ...this.fieldsToObject(filter),
             portalData: {}

package/dist/records/portal.d.ts

@@ -1,7 +1,7 @@
 import { PortalRecord } from './portalRecord.js';
-import { type RecordFieldsMap } from '../layouts/recordFieldsMap.js';
 import { type PortalBase } from './portalBase.js';
 import { type LayoutRecord } from './layoutRecord.js';
+import { RecordFieldsMap } from "../layouts/layoutInterface.js";
 /**
  * Represents a portal.
  *

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,10 +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;
@@ -25,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>>;
+    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

@@ -2,7 +2,7 @@ import type * as http from 'http';
 import { type FMError } from './FMError.js';
 import { type LayoutInterface } from './layouts/layoutInterface.js';
 import z from "zod";
-export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends string | number | symbol = ''> = Omit<LAYOUT, 'portals'> & {
+export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends keyof LAYOUT['portals'] = never> = Omit<LAYOUT, 'portals'> & {
     portals: Pick<LAYOUT['portals'], PORTALS>;
 };
 /** Shared database connection options. */

package/dist/utils/query.d.ts

@@ -1,23 +1,32 @@
-import { type Moment } from 'moment';
+import { Temporal } from 'temporal-polyfill';
 export declare const FindRequestSymbol: unique symbol;
-/** Represents a date, time, or timestamp value passed into `query(...)`. */
-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;
-/** Marks a value as a FileMaker date for use inside `query(...)`. */
-export declare function asDate(date: Date | Moment): TimestampType;
-/** Marks a value as a FileMaker time for use inside `query(...)`. */
-export declare function asTime(date: Date | Moment): TimestampType;
-/** Marks a value as a FileMaker timestamp for use inside `query(...)`. */
-export declare function asTimestamp(date: Date | Moment): TimestampType;
 export {};

package/dist/utils/query.js

@@ -1,9 +1,66 @@
 /*
  * 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) {
@@ -28,25 +85,3 @@ export function query(strings, ...args) {
     }).flat(1);
     return { [FindRequestSymbol]: query };
 }
-/** Marks a value as a FileMaker date for use inside `query(...)`. */
-export function asDate(date) {
-    return {
-        type: 'date',
-        moment: moment(date)
-    };
-}
-/** Marks a value as a FileMaker time for use inside `query(...)`. */
-export function asTime(date) {
-    return {
-        type: 'time',
-        moment: moment(date)
-    };
-}
-/** Marks a value as a FileMaker timestamp for use inside `query(...)`. */
-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' });
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.2",
   "dependencies": {
-    "commander": "^14.0.3",
-    "moment": "^2.30.1",
-    "zod": "^4.4.3"
+    "commander": "^15.0.0",
+    "temporal-polyfill": "^1.0.5",
+    "zod": "^4.6.5"
   },
   "type": "module",
   "main": "dist/index.js",
@@ -40,30 +40,30 @@
     "node": ">=22.22.3"
   },
   "devDependencies": {
-    "@babel/cli": "^7.29.7",
-    "@babel/core": "^7.29.7",
-    "@babel/preset-env": "^7.29.7",
-    "@babel/preset-typescript": "^7.29.7",
+    "@babel/cli": "^8.0.6",
+    "@babel/core": "^8.0.6",
+    "@babel/preset-env": "^8.0.6",
+    "@babel/preset-typescript": "^8.0.1",
     "@types/btoa": "^1.2.5",
     "@types/events": "^3.0.3",
     "@types/inquirer": "^9.0.10",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.19.21",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "babel-jest": "^29.7.0",
-    "dotenv": "^16.6.1",
-    "eslint": "^8.57.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.6.2",
+    "@typescript-eslint/eslint-plugin": "^8.70.1",
+    "babel-jest": "^30.5.2",
+    "dotenv": "^18.0.2",
+    "eslint": "^10.11.0",
     "eslint-config-standard-with-typescript": "^43.0.1",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-promise": "^6.6.0",
-    "inquirer": "^9.3.8",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.4.11",
-    "ts-morph": "^21.0.1",
-    "tsx": "^4.22.4",
-    "typedoc": "^0.28.19",
-    "typescript": "^5.9.3"
+    "eslint-plugin-n": "^18.3.0",
+    "eslint-plugin-promise": "^7.3.0",
+    "inquirer": "^14.2.2",
+    "jest": "^30.5.2",
+    "ts-jest": "^29.4.12",
+    "ts-morph": "^28.0.0",
+    "tsx": "^4.23.15",
+    "typedoc": "^0.28.20",
+    "typescript": "^6.0.3"
   },
   "bin": {
     "easyfm": "dist/bin/cli.js"
@@ -71,6 +71,7 @@
   "scripts": {
     "build": "tsc",
     "test": "npm run build && jest",
+    "test:types": "tsc --project tsconfig.test.json",
     "test:coverage": "jest --coverage --testPathIgnorePatterns='/__tests__/database.test.ts$'",
     "test:integration": "npm run build && jest __tests__/database.test.ts --runInBand",
     "test:unit": "jest __tests__/query.test.ts __tests__/CookieJar.test.ts --runInBand",