@pbkware/fielded-text-web 0.1.0

package/src/fields/instances/ft-float-field.ts

@@ -0,0 +1,44 @@
+import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
+import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
+import { FtFloatFieldDefinition } from '../definitions/ft-float-field-definition.js';
+import { FtGenericField } from './ft-generic-field.js';
+
+/**
+ * Field for float (number) values.
+ * @public
+ */
+export class FtFloatField extends FtGenericField<number> {
+  private static readonly VALUE_TEXT_NULL_TRIMMABLE = true;
+
+  constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtFloatFieldDefinition) {
+    super(sequenceInvokation, sequenceItem, FtFloatField.VALUE_TEXT_NULL_TRIMMABLE, definition);
+  }
+
+  override get definition(): FtFloatFieldDefinition {
+    return super.definition_ as FtFloatFieldDefinition;
+  }
+
+  get format(): string {
+    return this.definition.format;
+  }
+
+  get styles(): number {
+    return this.definition.styles;
+  }
+
+  get nullableValue(): number | null {
+    return this.isNull() ? null : this.value;
+  }
+
+  set nullableValue(value: number | null) {
+    if (value === null) {
+      this.setNull();
+    } else {
+      this.value = value;
+    }
+  }
+
+  protected isValueEqual(left: number, right: number): boolean {
+    return left === right;
+  }
+}

package/src/fields/instances/ft-generic-field.ts

@@ -0,0 +1,219 @@
+import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
+import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
+import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
+import { FtGenericFieldDefinition } from '../definitions/ft-generic-field-definition.js';
+import { FtField } from './ft-field.js';
+
+/**
+ * Generic base class for typed fields.
+ * Provides type-safe value access and implements conversion methods.
+ * @public
+ */
+export abstract class FtGenericField<T> extends FtField {
+  private _value!: T;
+
+  protected constructor(
+    sequenceInvokation: FtSequenceInvokation,
+    sequenceItem: FtSequenceItem,
+    valueTextNullTrimmable: boolean,
+    definition: FtGenericFieldDefinition<T>,
+  ) {
+    super(sequenceInvokation, sequenceItem, valueTextNullTrimmable);
+
+    // Verify the sequenceItem's definition matches the provided definition
+    if (sequenceItem.fieldDefinition !== definition) {
+      throw new Error('SequenceItem definition must match provided definition');
+    }
+
+    if (definition.constant && !definition.null) {
+      this._value = definition.value;
+    }
+  }
+
+  override get definition_(): FtGenericFieldDefinition<T> {
+    return super.definition_ as FtGenericFieldDefinition<T>;
+  }
+
+  get value(): T {
+    return this.getValueOrThrowNull();
+  }
+
+  set value(val: T) {
+    this.setValue(val); // ignore fieldsAffectedFromIndex for direct value sets, as sequence redirects are not expected in this case
+  }
+
+  setValue(val: T): number {
+    if (this.constant) {
+      throw new Error(`Cannot set constant field "${this.name}"`);
+    } else {
+      this.clearNonConstantNull();
+      this._value = val;
+      this.valueAssigned = true;
+      return this.checkValueSequenceRedirect(); // returns fieldsAffectedFromIndex
+    }
+  }
+
+  protected getAsNonNullValueText(): string {
+    try {
+      return this.definition_.getValueText(this._value);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to convert field "${this.name}" to text: ${message}`, { cause: error });
+    }
+  }
+
+  protected getAsNonNullObject(): unknown {
+    return this._value;
+  }
+
+  protected getAsNonNullString(): string {
+    return String(this._value);
+  }
+
+  protected getAsBoolean(): boolean {
+    return Boolean(this._value);
+  }
+
+  protected getAsInteger(): number {
+    return Number(this._value);
+  }
+
+  protected getAsBigInt(): bigint {
+    if (typeof this._value === 'bigint') {
+      return this._value;
+    }
+    return BigInt(Number(this._value));
+  }
+
+  protected getAsFloat(): number {
+    return Number(this._value);
+  }
+
+  protected getAsDateTime(): Date {
+    if (this._value instanceof Date) {
+      return this._value;
+    }
+    return new Date(Number(this._value));
+  }
+
+  protected getAsDecimal(): number {
+    return Number(this._value);
+  }
+
+  protected setAsNonNullObject(newValue: unknown): void {
+    this.value = newValue as T;
+  }
+
+  protected setAsNonNullString(newValue: string): void {
+    this.value = newValue as unknown as T;
+  }
+
+  protected setAsBoolean(newValue: boolean): void {
+    this.value = newValue as unknown as T;
+  }
+
+  protected setAsInteger(newValue: number): void {
+    this.value = newValue as unknown as T;
+  }
+
+  protected setAsBigInt(newValue: bigint): void {
+    this.value = newValue as unknown as T;
+  }
+
+  protected setAsFloat(newValue: number): void {
+    this.value = newValue as unknown as T;
+  }
+
+  protected setAsDateTime(newValue: Date): void {
+    this.value = newValue as unknown as T;
+  }
+
+  protected setAsDecimal(newValue: number): void {
+    this.value = newValue as unknown as T;
+  }
+
+  protected getAsRedirectBoolean(): boolean {
+    return Boolean(this._value);
+  }
+
+  protected getAsRedirectInteger(): bigint {
+    if (typeof this._value === 'bigint') {
+      return this._value;
+    }
+    return BigInt(Number(this._value));
+  }
+
+  protected getAsRedirectFloat(): number {
+    return Number(this._value);
+  }
+
+  protected getAsRedirectDateTime(): Date {
+    if (this._value instanceof Date) {
+      return this._value;
+    }
+    return new Date(Number(this._value));
+  }
+
+  protected getAsRedirectDecimal(): number {
+    return Number(this._value);
+  }
+
+  protected loadNonNullValue(valueText: string): void {
+    if (!this.constant) {
+      this.clearNonConstantNull();
+      this._value = this.definition_.parseValueText(valueText);
+      this.valueAssigned = true;
+      this.checkValueSequenceRedirect(); // ignore fieldsAffectedFromIndex for value loads, as sequence redirects are not expected in this case
+    } else {
+      if (this.isNull()) {
+        throw new Error(`Constant field "${this.name}" expected null but got value: ${valueText}`);
+      } else {
+        const parsedValue = this.definition_.parseValueText(valueText);
+        if (!this.isValueEqual(this._value, parsedValue)) {
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          throw new Error(`Constant field "${this.name}" value mismatch: expected ${this._value}, got ${valueText}`);
+        }
+      }
+    }
+  }
+
+  private getValueOrThrowNull(): T {
+    if (this.isNull()) {
+      throw new Error(`Attempt to get value from null field "${this.name}"`);
+    }
+    return this._value;
+  }
+
+  private checkValueSequenceRedirect(): number {
+    if (this.sequenceRedirectList.count > 0 && !this.sidelined) {
+      let redirected = false;
+      for (let i = 0; i < this.sequenceRedirectList.count; i++) {
+        const redirect = this.sequenceRedirectList.get(i);
+        if (redirect.type !== FtSequenceRedirectType.Null) {
+          if (redirect.checkTriggered(this)) {
+            if (redirect.sequence) {
+              return this.onSequenceRedirect(redirect.sequence, redirect.invokationDelay); // returns fieldsAffectedFromIndex
+            }
+            redirected = true;
+            break;
+          }
+        }
+      }
+
+      if (!redirected) {
+        // In case was previously redirected
+        return this.onSequenceRedirect(undefined, FtField.IGNORED_SEQUENCE_INVOKATION_DELAY); // returns fieldsAffectedFromIndex
+      }
+    }
+
+    return FtField.NO_FIELDS_AFFECTED_INDEX;
+  }
+
+  /**
+   * Check if two values are equal.
+   * @param left - Left value
+   * @param right - Right value
+   * @returns true if values are equal
+   */
+  protected abstract isValueEqual(left: T, right: T): boolean;
+}

package/src/fields/instances/ft-integer-field.ts

@@ -0,0 +1,44 @@
+import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
+import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
+import { FtIntegerFieldDefinition } from '../definitions/ft-integer-field-definition.js';
+import { FtGenericField } from './ft-generic-field.js';
+
+/**
+ * Field for integer (bigint) values.
+ * @public
+ */
+export class FtIntegerField extends FtGenericField<bigint> {
+  private static readonly VALUE_TEXT_NULL_TRIMMABLE = true;
+
+  constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtIntegerFieldDefinition) {
+    super(sequenceInvokation, sequenceItem, FtIntegerField.VALUE_TEXT_NULL_TRIMMABLE, definition);
+  }
+
+  override get definition(): FtIntegerFieldDefinition {
+    return super.definition_ as FtIntegerFieldDefinition;
+  }
+
+  get format(): string {
+    return this.definition.format;
+  }
+
+  get styles(): number {
+    return this.definition.styles;
+  }
+
+  get nullableValue(): bigint | null {
+    return this.isNull() ? null : this.value;
+  }
+
+  set nullableValue(value: bigint | null) {
+    if (value === null) {
+      this.setNull();
+    } else {
+      this.value = value;
+    }
+  }
+
+  protected isValueEqual(left: bigint, right: bigint): boolean {
+    return left === right;
+  }
+}

package/src/fields/instances/ft-string-field.ts

@@ -0,0 +1,40 @@
+import { FtSequenceInvokation } from '../../sequences/core/ft-sequence-invokation.js';
+import { FtSequenceItem } from '../../sequences/core/ft-sequence-item.js';
+import { FtStringFieldDefinition } from '../definitions/ft-string-field-definition.js';
+import { FtGenericField } from './ft-generic-field.js';
+
+/**
+ * Field for string values.
+ * @public
+ */
+export class FtStringField extends FtGenericField<string> {
+  private static readonly VALUE_TEXT_NULL_TRIMMABLE = false;
+
+  constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtStringFieldDefinition) {
+    super(sequenceInvokation, sequenceItem, FtStringField.VALUE_TEXT_NULL_TRIMMABLE, definition);
+  }
+
+  get nullableValue(): string | null {
+    return this.isNull() ? null : this.value;
+  }
+
+  set nullableValue(value: string | null) {
+    if (value === null) {
+      this.setNull();
+    } else {
+      this.value = value;
+    }
+  }
+
+  override setValue(value: string | null): number {
+    if (value === null) {
+      return this.setNull(); // returns fieldsAffectedFromIndex
+    } else {
+      return super.setValue(value); // returns fieldsAffectedFromIndex
+    }
+  }
+
+  protected isValueEqual(left: string, right: string): boolean {
+    return left === right;
+  }
+}

package/src/index.ts

@@ -0,0 +1,185 @@
+// Re-export formatting classes from dependency
+export {
+  DotNetDateTimeStyleFlags,
+  DotNetDateTimeStyles,
+  DotNetLocaleSettings,
+  DotNetNumberStyleFlags,
+  DotNetNumberStyles,
+} from '@pbkware/dot-net-date-number-formatting';
+
+export { Result } from '@pbkware/js-utils';
+
+// Enums
+export { FtBooleanStyles } from './types/enums/ft-boolean-styles.js';
+export { FtEndOfLineAutoWriteType } from './types/enums/ft-end-of-line-auto-write-type.js';
+export { FtEndOfLineType } from './types/enums/ft-end-of-line-type.js';
+export { FtHeadingConstraint } from './types/enums/ft-heading-constraint.js';
+export { FtLastLineEndedType } from './types/enums/ft-last-line-ended-type.js';
+export { FtLineType } from './types/enums/ft-line-type.js';
+export { FtMetaElementType } from './types/enums/ft-meta-element-type.js';
+export { FtMetaReferenceType } from './types/enums/ft-meta-reference-type.js';
+export { FtMetaSerializationFormat } from './types/enums/ft-meta-serialization-format.js';
+export { FtPadAlignment } from './types/enums/ft-pad-alignment.js';
+export { FtPadCharType } from './types/enums/ft-pad-char-type.js';
+export { FtQuotedType } from './types/enums/ft-quoted-type.js';
+export { FtReadRecordResult } from './types/enums/ft-read-record-result.js';
+export { FtSequenceInvokationDelay } from './types/enums/ft-sequence-invokation-delay.js';
+export { FtSubstitutionType } from './types/enums/ft-substitution-type.js';
+export { FtTruncateType } from './types/enums/ft-truncate-type.js';
+
+// Standard types with companion Info namespaces
+export { FtDataType } from './types/enums/ft-data-type.js';
+export { FtSequenceRedirectType } from './types/enums/ft-sequence-redirect-type.js';
+
+// Core meta classes
+export { FtBooleanMetaField } from './meta/fields/ft-boolean-meta-field.js';
+export { FtDateTimeMetaField } from './meta/fields/ft-date-time-meta-field.js';
+export { FtDecimalMetaField } from './meta/fields/ft-decimal-meta-field.js';
+export { FtFloatMetaField } from './meta/fields/ft-float-meta-field.js';
+export { FtGenericMetaField } from './meta/fields/ft-generic-meta-field.js';
+export { FtIntegerMetaField } from './meta/fields/ft-integer-meta-field.js';
+export { FtMetaFieldList } from './meta/fields/ft-meta-field-list.js';
+export { FtMetaField } from './meta/fields/ft-meta-field.js';
+export { FtStringMetaField } from './meta/fields/ft-string-meta-field.js';
+export { FtMetaDefaults } from './meta/ft-meta-defaults.js';
+export { FtMeta, FtMetaPropertyId } from './meta/ft-meta.js';
+export { FtMetaSequenceItemList } from './meta/sequences/core/ft-meta-sequence-item-list.js';
+export { FtMetaSequenceItem } from './meta/sequences/core/ft-meta-sequence-item.js';
+export { FtMetaSequenceList } from './meta/sequences/core/ft-meta-sequence-list.js';
+export { FtMetaSequence } from './meta/sequences/core/ft-meta-sequence.js';
+export { FtBooleanMetaSequenceRedirect } from './meta/sequences/redirects/ft-boolean-meta-sequence-redirect.js';
+export { FtCaseInsensitiveStringMetaSequenceRedirect } from './meta/sequences/redirects/ft-case-insensitive-string-meta-sequence-redirect.js';
+export { FtDateMetaSequenceRedirect } from './meta/sequences/redirects/ft-date-meta-sequence-redirect.js';
+export { FtExactDateTimeMetaSequenceRedirect } from './meta/sequences/redirects/ft-exact-date-time-meta-sequence-redirect.js';
+export { FtExactDecimalMetaSequenceRedirect } from './meta/sequences/redirects/ft-exact-decimal-meta-sequence-redirect.js';
+export { FtExactFloatMetaSequenceRedirect } from './meta/sequences/redirects/ft-exact-float-meta-sequence-redirect.js';
+export { FtExactIntegerMetaSequenceRedirect } from './meta/sequences/redirects/ft-exact-integer-meta-sequence-redirect.js';
+export { FtExactStringMetaSequenceRedirect } from './meta/sequences/redirects/ft-exact-string-meta-sequence-redirect.js';
+export { FtMetaSequenceRedirectList } from './meta/sequences/redirects/ft-meta-sequence-redirect-list.js';
+export { FtMetaSequenceRedirect } from './meta/sequences/redirects/ft-meta-sequence-redirect.js';
+export { FtNullMetaSequenceRedirect } from './meta/sequences/redirects/ft-null-meta-sequence-redirect.js';
+export { FtMetaSubstitution, FtMetaSubstitutionList } from './meta/substitutions/ft-meta-substitution-list.js';
+
+// Substitutions
+export { FtSubstitution } from './substitutions/ft-substitution-list.js';
+
+// Sequence infrastructure
+export { FtSequenceInvokation, FtSequenceRedirectDelegate } from './sequences/core/ft-sequence-invokation.js';
+export { FtSequenceItemList } from './sequences/core/ft-sequence-item-list.js';
+export { FtSequenceItem } from './sequences/core/ft-sequence-item.js';
+export { FtSequenceList } from './sequences/core/ft-sequence-list.js';
+export { FtSequence } from './sequences/core/ft-sequence.js';
+export { FtSequenceRedirectList } from './sequences/redirects/ft-sequence-redirect-list.js';
+export { FtSequenceRedirect } from './sequences/redirects/ft-sequence-redirect.js';
+
+// Sequence redirects
+export { FtBooleanSequenceRedirect } from './sequences/redirects/ft-boolean-sequence-redirect.js';
+export { FtCaseInsensitiveStringSequenceRedirect } from './sequences/redirects/ft-case-insensitive-string-sequence-redirect.js';
+export { FtDateSequenceRedirect } from './sequences/redirects/ft-date-sequence-redirect.js';
+export { FtExactDateTimeSequenceRedirect } from './sequences/redirects/ft-exact-date-time-sequence-redirect.js';
+export { FtExactDecimalSequenceRedirect } from './sequences/redirects/ft-exact-decimal-sequence-redirect.js';
+export { FtExactFloatSequenceRedirect } from './sequences/redirects/ft-exact-float-sequence-redirect.js';
+export { FtExactIntegerSequenceRedirect } from './sequences/redirects/ft-exact-integer-sequence-redirect.js';
+export { FtExactStringSequenceRedirect } from './sequences/redirects/ft-exact-string-sequence-redirect.js';
+export { FtNullSequenceRedirect } from './sequences/redirects/ft-null-sequence-redirect.js';
+
+// Factories
+export { FtFieldFactory } from './factory/ft-field-factory.js';
+export { FtMetaConstructor } from './factory/ft-meta-constructor.js';
+export { FtMetaFactory } from './factory/ft-meta-factory.js';
+export { FtSequenceConstructor } from './factory/ft-sequence-constructor.js';
+export { FtSequenceFactory } from './factory/ft-sequence-factory.js';
+export { FtSequenceItemConstructor } from './factory/ft-sequence-item-constructor.js';
+export { FtSequenceItemFactory } from './factory/ft-sequence-item-factory.js';
+export { FtSequenceRedirectConstructor } from './factory/ft-sequence-redirect-constructor.js';
+export { FtSequenceRedirectFactory } from './factory/ft-sequence-redirect-factory.js';
+export { FtSubstitutionConstructor } from './factory/ft-substitution-constructor.js';
+export { FtSubstitutionFactory } from './factory/ft-substitution-factory.js';
+
+// Field definitions
+export { FtBooleanFieldDefinition } from './fields/definitions/ft-boolean-field-definition.js';
+export { FtDateTimeFieldDefinition } from './fields/definitions/ft-date-time-field-definition.js';
+export { FtDecimalFieldDefinition } from './fields/definitions/ft-decimal-field-definition.js';
+export { FtFieldDefinitionList } from './fields/definitions/ft-field-definition-list.js';
+export { FtFieldDefinition } from './fields/definitions/ft-field-definition.js';
+export { FtFloatFieldDefinition } from './fields/definitions/ft-float-field-definition.js';
+export { FtGenericFieldDefinition } from './fields/definitions/ft-generic-field-definition.js';
+export { FtIntegerFieldDefinition } from './fields/definitions/ft-integer-field-definition.js';
+export { FtStringFieldDefinition } from './fields/definitions/ft-string-field-definition.js';
+
+// Fields
+export { FtBooleanField } from './fields/instances/ft-boolean-field.js';
+export { FtDateTimeField } from './fields/instances/ft-date-time-field.js';
+export { FtDecimalField } from './fields/instances/ft-decimal-field.js';
+export { FtField } from './fields/instances/ft-field.js';
+export { FtFloatField } from './fields/instances/ft-float-field.js';
+export { FtGenericField } from './fields/instances/ft-generic-field.js';
+export { FtIntegerField } from './fields/instances/ft-integer-field.js';
+export { FtStringField } from './fields/instances/ft-string-field.js';
+
+// Field formatters
+export { FtBooleanFieldFormatter } from './serialization/formatting/ft-boolean-field-formatter.js';
+export { FtDateTimeFieldFormatter } from './serialization/formatting/ft-date-time-field-formatter.js';
+export { FtDecimalFieldFormatter } from './serialization/formatting/ft-decimal-field-formatter.js';
+export { FtFieldFormatter } from './serialization/formatting/ft-field-formatter.js';
+export { FtFloatFieldFormatter } from './serialization/formatting/ft-float-field-formatter.js';
+export { FtIntegerFieldFormatter } from './serialization/formatting/ft-integer-field-formatter.js';
+export { FtStringFieldFormatter } from './serialization/formatting/ft-string-field-formatter.js';
+
+// Meta serialization
+export { FtJsonMetaSerialization } from './meta-serialization/format/ft-json-meta-serialization.js';
+export { FtXmlMetaSerialization } from './meta-serialization/format/ft-xml-meta-serialization.js';
+export { FtMetaSerializerOptions } from './meta-serialization/format/meta-serializer-options.js';
+export { FtMetaSerialization } from './meta-serialization/ft-meta-serialization.js';
+export { FtDateTimeStylesMetaSerialization } from './meta-serialization/styles/ft-date-time-styles-meta-serialization.js';
+export { FtNumberStylesMetaSerialization } from './meta-serialization/styles/ft-number-styles-meta-serialization.js';
+
+// Serialization errors and exceptions
+export { FtSerializationError } from './types/errors/ft-serialization-error.js';
+export { FtSerializationException } from './types/errors/ft-serialization-exception.js';
+
+// Serialization reader
+export { FtDeclaredParameterRec, FtDeclaredParameters } from './serialization/ft-declared-parameters.js';
+export { FtSerializationReader } from './serialization/ft-serialization-reader.js';
+export { FtStringReader, FtTextReader } from './serialization/ft-text-reader.js';
+
+// Serialization writer
+export { FtWriterSettings } from './api/ft-writer-settings.js';
+export { FtDeclaredParametersFormatter } from './serialization/formatting/ft-declared-parameters-formatter.js';
+export { FtSerializationWriter } from './serialization/ft-serialization-writer.js';
+export { FtCallbackTextWriter, FtStringWriter, FtTextWriter } from './serialization/ft-text-writer.js';
+
+// High-level API
+export { FtReader } from './api/ft-reader.js';
+export { FtAbortSerializationException, FtSerialization } from './api/ft-serialization.js';
+export { FtWriter } from './api/ft-writer.js';
+
+// Event args (type-only exports for interfaces)
+/**
+ * @public
+ */
+export type { FtFieldHeadingReadyEventArgs } from './types/events/ft-field-heading-ready-event-args.js';
+/**
+ * @public
+ */
+export type { FtFieldValueReadyEventArgs } from './types/events/ft-field-value-ready-event-args.js';
+/**
+ * @public
+ */
+export type { FtHeadingLineFinishedEventArgs } from './types/events/ft-heading-line-finished-event-args.js';
+/**
+ * @public
+ */
+export type { FtHeadingLineStartedEventArgs } from './types/events/ft-heading-line-started-event-args.js';
+/**
+ * @public
+ */
+export type { FtRecordFinishedEventArgs } from './types/events/ft-record-finished-event-args.js';
+/**
+ * @public
+ */
+export type { FtRecordStartedEventArgs } from './types/events/ft-record-started-event-args.js';
+/**
+ * @public
+ */
+export type { FtSequenceRedirectedEventArgs } from './types/events/ft-sequence-redirected-event-args.js';

package/src/meta/fields/ft-boolean-meta-field.ts

@@ -0,0 +1,79 @@
+import { FtBooleanStyles } from '../../types/enums/ft-boolean-styles.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
+import { FtMetaDefaults } from '../ft-meta-defaults.js';
+import { FtGenericMetaField } from './ft-generic-meta-field.js';
+import { FtMetaField } from './ft-meta-field.js';
+
+/**
+ * Meta field for boolean values.
+ * @public
+ */
+export class FtBooleanMetaField extends FtGenericMetaField<boolean> {
+  static readonly DATA_TYPE = FtDataType.Boolean;
+
+  static readonly DEFAULT_FALSE_TEXT = FtMetaDefaults.BooleanField.FalseText;
+  static readonly DEFAULT_TRUE_TEXT = FtMetaDefaults.BooleanField.TrueText;
+  static readonly DEFAULT_STYLES = FtMetaDefaults.BooleanField.Styles;
+  static readonly DEFAULT_VALUE = FtMetaDefaults.BooleanField.Value;
+  static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE = FtMetaDefaults.BooleanField.SequenceRedirectType;
+
+  private _falseText: string = FtBooleanMetaField.DEFAULT_FALSE_TEXT;
+  private _trueText: string = FtBooleanMetaField.DEFAULT_TRUE_TEXT;
+  private _styles: FtBooleanStyles = FtBooleanMetaField.DEFAULT_STYLES;
+
+  constructor(headingCount = 0) {
+    super(FtBooleanMetaField.DATA_TYPE, headingCount, FtBooleanMetaField.DEFAULT_VALUE);
+  }
+
+  get falseText(): string {
+    return this._falseText;
+  }
+  set falseText(value: string) {
+    this._falseText = value;
+  }
+
+  get trueText(): string {
+    return this._trueText;
+  }
+  set trueText(value: string) {
+    this._trueText = value;
+  }
+
+  get styles(): FtBooleanStyles {
+    return this._styles;
+  }
+  set styles(value: FtBooleanStyles) {
+    this._styles = value;
+  }
+
+  static isBooleanMetaField(field: FtMetaField): field is FtBooleanMetaField {
+    return field.dataType === FtBooleanMetaField.DATA_TYPE;
+  }
+
+  override loadDefaults(leaveNameAsIs = true): void {
+    super.loadDefaults(leaveNameAsIs);
+    this._falseText = FtBooleanMetaField.DEFAULT_FALSE_TEXT;
+    this._trueText = FtBooleanMetaField.DEFAULT_TRUE_TEXT;
+    this._styles = FtBooleanMetaField.DEFAULT_STYLES;
+  }
+
+  createCopy(): FtMetaField {
+    const field = new FtBooleanMetaField(this.headingCount);
+    field.assignFrom(this);
+    return field;
+  }
+
+  protected getDefaultSequenceRedirectType(): FtSequenceRedirectType {
+    return FtBooleanMetaField.DEFAULT_SEQUENCE_REDIRECT_TYPE;
+  }
+
+  protected override assignFrom(source: FtMetaField): void {
+    super.assignFrom(source);
+    if (source instanceof FtBooleanMetaField) {
+      this._falseText = source._falseText;
+      this._trueText = source._trueText;
+      this._styles = source._styles;
+    }
+  }
+}

package/src/meta/fields/ft-date-time-meta-field.ts

@@ -0,0 +1,68 @@
+import { DotNetDateTimeStyles } from '@pbkware/dot-net-date-number-formatting';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
+import { FtMetaDefaults } from '../ft-meta-defaults.js';
+import { FtGenericMetaField } from './ft-generic-meta-field.js';
+import { FtMetaField } from './ft-meta-field.js';
+
+/**
+ * Meta field for Date/Time values.
+ * @public
+ */
+export class FtDateTimeMetaField extends FtGenericMetaField<Date> {
+  static readonly DATA_TYPE = FtDataType.DateTime;
+
+  static readonly DEFAULT_FORMAT = FtMetaDefaults.DateTimeField.Format;
+  static readonly DEFAULT_STYLES = FtMetaDefaults.DateTimeField.Styles;
+  static readonly DEFAULT_VALUE = FtMetaDefaults.DateTimeField.Value;
+  static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE = FtMetaDefaults.DateTimeField.SequenceRedirectType;
+
+  private _format: string = FtDateTimeMetaField.DEFAULT_FORMAT;
+  private _styles: DotNetDateTimeStyles = FtDateTimeMetaField.DEFAULT_STYLES;
+
+  constructor(headingCount = 0) {
+    super(FtDateTimeMetaField.DATA_TYPE, headingCount, new Date(FtDateTimeMetaField.DEFAULT_VALUE));
+  }
+
+  get format(): string {
+    return this._format;
+  }
+  set format(value: string) {
+    this._format = value;
+  }
+
+  get styles(): DotNetDateTimeStyles {
+    return this._styles;
+  }
+  set styles(value: DotNetDateTimeStyles) {
+    this._styles = value;
+  }
+
+  static isDateTimeMetaField(field: FtMetaField): field is FtDateTimeMetaField {
+    return field.dataType === FtDateTimeMetaField.DATA_TYPE;
+  }
+
+  override loadDefaults(leaveNameAsIs = true): void {
+    super.loadDefaults(leaveNameAsIs);
+    this._format = FtDateTimeMetaField.DEFAULT_FORMAT;
+    this._styles = FtDateTimeMetaField.DEFAULT_STYLES;
+  }
+
+  createCopy(): FtMetaField {
+    const field = new FtDateTimeMetaField(this.headingCount);
+    field.assignFrom(this);
+    return field;
+  }
+
+  protected getDefaultSequenceRedirectType(): FtSequenceRedirectType {
+    return FtDateTimeMetaField.DEFAULT_SEQUENCE_REDIRECT_TYPE;
+  }
+
+  protected override assignFrom(source: FtMetaField): void {
+    super.assignFrom(source);
+    if (source instanceof FtDateTimeMetaField) {
+      this._format = source._format;
+      this._styles = source._styles;
+    }
+  }
+}