@pbkware/fielded-text-web 0.1.0

package/src/meta/sequences/redirects/ft-exact-string-meta-sequence-redirect.ts

@@ -0,0 +1,49 @@
+// Exact string meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific string (case-sensitive).
+ * Used in metadata to define sequence transitions based on exact string field values.
+ * @public
+ */
+export class FtExactStringMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for exact string redirects */
+  static readonly TYPE = FtSequenceRedirectType.ExactString;
+  /** Default string value */
+  static readonly DEFAULT_VALUE = '';
+
+  private _value: string;
+
+  constructor() {
+    super(FtExactStringMetaSequenceRedirect.TYPE);
+    this._value = FtExactStringMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  /** The string value to match exactly for triggering the redirect */
+  get value(): string {
+    return this._value;
+  }
+
+  set value(val: string) {
+    this._value = val;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    this._value = FtExactStringMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtExactStringMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = (source as FtExactStringMetaSequenceRedirect)._value;
+  }
+}

package/src/meta/sequences/redirects/ft-meta-sequence-redirect-list.ts

@@ -0,0 +1,99 @@
+// Meta sequence redirect list - manages redirects for a sequence item
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import { FtUnreachableCaseError } from '../../../types/errors/ft-internal-error.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtBooleanMetaSequenceRedirect } from './ft-boolean-meta-sequence-redirect.js';
+import { FtCaseInsensitiveStringMetaSequenceRedirect } from './ft-case-insensitive-string-meta-sequence-redirect.js';
+import { FtDateMetaSequenceRedirect } from './ft-date-meta-sequence-redirect.js';
+import { FtExactDateTimeMetaSequenceRedirect } from './ft-exact-date-time-meta-sequence-redirect.js';
+import { FtExactDecimalMetaSequenceRedirect } from './ft-exact-decimal-meta-sequence-redirect.js';
+import { FtExactFloatMetaSequenceRedirect } from './ft-exact-float-meta-sequence-redirect.js';
+import { FtExactIntegerMetaSequenceRedirect } from './ft-exact-integer-meta-sequence-redirect.js';
+import { FtExactStringMetaSequenceRedirect } from './ft-exact-string-meta-sequence-redirect.js';
+import type { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+import { FtNullMetaSequenceRedirect } from './ft-null-meta-sequence-redirect.js';
+
+/**
+ * List of meta sequence redirects for a sequence item.
+ * Manages the collection of redirects that determine when to switch sequences.
+ * @public
+ */
+export class FtMetaSequenceRedirectList {
+  private readonly _list: FtMetaSequenceRedirect[] = [];
+
+  get count(): number {
+    return this._list.length;
+  }
+
+  get(index: number): FtMetaSequenceRedirect {
+    return this._list[index];
+  }
+
+  set(redirects: readonly FtMetaSequenceRedirect[]): void {
+    const count = redirects.length;
+    this._list.length = count;
+    for (let i = 0; i < count; i++) {
+      this._list[i] = redirects[i];
+    }
+  }
+
+  new(type: FtSequenceRedirectType): FtMetaSequenceRedirect {
+    const redirect = this.createMetaSequenceRedirect(type);
+    this.add(redirect);
+    return redirect;
+  }
+
+  remove(redirect: FtMetaSequenceRedirect): void {
+    const index = this._list.indexOf(redirect);
+    if (index >= 0) {
+      this._list.splice(index, 1);
+    }
+  }
+
+  removeAt(index: number): void {
+    this._list.splice(index, 1);
+  }
+
+  clear(): void {
+    this._list.length = 0;
+  }
+
+  assign(source: FtMetaSequenceRedirectList, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    this._list.length = 0;
+
+    for (let i = 0; i < source.count; i++) {
+      const redirect = source.get(i).createCopy(sequenceList, sourceSequenceList);
+      this.add(redirect);
+    }
+  }
+
+  private add(redirect: FtMetaSequenceRedirect): void {
+    this._list.push(redirect);
+  }
+
+  private createMetaSequenceRedirect(type: FtSequenceRedirectType): FtMetaSequenceRedirect {
+    switch (type) {
+      case FtSequenceRedirectType.Null:
+        return new FtNullMetaSequenceRedirect();
+      case FtSequenceRedirectType.Boolean:
+        return new FtBooleanMetaSequenceRedirect();
+      case FtSequenceRedirectType.ExactString:
+        return new FtExactStringMetaSequenceRedirect();
+      case FtSequenceRedirectType.CaseInsensitiveString:
+        return new FtCaseInsensitiveStringMetaSequenceRedirect();
+      case FtSequenceRedirectType.ExactInteger:
+        return new FtExactIntegerMetaSequenceRedirect();
+      case FtSequenceRedirectType.ExactFloat:
+        return new FtExactFloatMetaSequenceRedirect();
+      case FtSequenceRedirectType.ExactDecimal:
+        return new FtExactDecimalMetaSequenceRedirect();
+      case FtSequenceRedirectType.ExactDateTime:
+        return new FtExactDateTimeMetaSequenceRedirect();
+      case FtSequenceRedirectType.Date:
+        return new FtDateMetaSequenceRedirect();
+      default:
+        throw new FtUnreachableCaseError('MSRLCMSR22113', type);
+    }
+  }
+}

package/src/meta/sequences/redirects/ft-meta-sequence-redirect.ts

@@ -0,0 +1,89 @@
+// Abstract base class for meta sequence redirects
+
+import { FtSequenceInvokationDelay } from '../../../types/enums/ft-sequence-invokation-delay.js';
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import type { FtMetaSequence } from '../core/ft-meta-sequence.js';
+
+/**
+ * Default invokation delay for sequence redirects.
+ * @public
+ */
+export const DEFAULT_INVOKATION_DELAY = FtSequenceInvokationDelay.AfterField;
+
+/**
+ * Abstract base class for meta sequence redirects.
+ * Sequence redirects define conditional transitions from one sequence to another
+ * based on field values in the metadata.
+ * @public
+ */
+export abstract class FtMetaSequenceRedirect {
+  private readonly _type: FtSequenceRedirectType;
+  private _sequence: FtMetaSequence | undefined;
+  private _invokationDelay: FtSequenceInvokationDelay;
+
+  protected constructor(type: FtSequenceRedirectType) {
+    this._type = type;
+    this._invokationDelay = DEFAULT_INVOKATION_DELAY;
+  }
+
+  /** The type identifier for this redirect */
+  get type(): FtSequenceRedirectType {
+    return this._type;
+  }
+
+  /** The target sequence to redirect to when this redirect is triggered */
+  get sequence(): FtMetaSequence | undefined {
+    return this._sequence;
+  }
+
+  set sequence(value: FtMetaSequence | undefined) {
+    this._sequence = value;
+  }
+
+  /** When the redirect should be invoked relative to field processing */
+  get invokationDelay(): FtSequenceInvokationDelay {
+    return this._invokationDelay;
+  }
+
+  set invokationDelay(value: FtSequenceInvokationDelay) {
+    this._invokationDelay = value;
+  }
+
+  /** Reset this redirect to default values */
+  loadDefaults(): void {
+    this._invokationDelay = DEFAULT_INVOKATION_DELAY;
+  }
+
+  /**
+   * Assign values from another redirect to this one.
+   * @param source - The source redirect to copy from
+   * @param sequenceList - The destination sequence list
+   * @param sourceSequenceList - The source sequence list
+   * @internal
+   */
+  protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    this._invokationDelay = source._invokationDelay;
+
+    if (source._sequence) {
+      const sequenceIndex = sourceSequenceList.indexOf(source._sequence);
+      if (sequenceIndex < 0) {
+        throw new Error('Source sequence not found in source sequence list');
+      }
+      if (sequenceIndex >= sequenceList.count) {
+        throw new Error(`Sequence index ${sequenceIndex} out of range`);
+      }
+      this._sequence = sequenceList.get(sequenceIndex);
+    } else {
+      this._sequence = undefined;
+    }
+  }
+
+  /**
+   * Create a deep copy of this redirect.
+   * @param sequenceList - The destination sequence list
+   * @param sourceSequenceList - The source sequence list
+   * @returns A new redirect instance with copied values
+   */
+  abstract createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+}

package/src/meta/sequences/redirects/ft-null-meta-sequence-redirect.ts

@@ -0,0 +1,25 @@
+// Null meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value is null.
+ * Used in metadata to define sequence transitions based on null field values.
+ * @public
+ */
+export class FtNullMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for null redirects */
+  static readonly TYPE = FtSequenceRedirectType.Null;
+
+  constructor() {
+    super(FtNullMetaSequenceRedirect.TYPE);
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtNullMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+}

package/src/meta/substitutions/ft-meta-substitution-list.ts

@@ -0,0 +1,54 @@
+import { FtSubstitutionFactory } from '../../factory/ft-substitution-factory.js';
+import { FtSubstitutionType } from '../../types/enums/ft-substitution-type.js';
+import { FtMetaDefaults } from '../ft-meta-defaults.js';
+
+/**
+ * @public
+ */
+export class FtMetaSubstitution {
+  constructor(
+    public id = 0,
+    public token: string = FtMetaDefaults.Substitution.Token,
+    public type: FtSubstitutionType = FtMetaDefaults.Substitution.Type,
+    public value = '',
+  ) {}
+}
+
+/**
+ * @public
+ */
+export class FtMetaSubstitutionList {
+  private substitutions: FtMetaSubstitution[] = [];
+
+  get count(): number {
+    return this.substitutions.length;
+  }
+
+  get(index: number): FtMetaSubstitution {
+    return this.substitutions[index];
+  }
+
+  new(type: FtSubstitutionType = FtSubstitutionType.String, token = '\\', value = ''): FtMetaSubstitution {
+    const sub = FtSubstitutionFactory.createMetaSubstitution();
+    sub.id = this.substitutions.length;
+    sub.type = type;
+    sub.token = token;
+    sub.value = value;
+    this.substitutions.push(sub);
+    return sub;
+  }
+
+  clear(): void {
+    this.substitutions = [];
+  }
+
+  assign(source: FtMetaSubstitutionList): void {
+    this.clear();
+
+    for (let i = 0; i < source.count; i++) {
+      const sourceSub = source.get(i);
+      const targetSub = this.new(sourceSub.type, sourceSub.token, sourceSub.value);
+      targetSub.id = sourceSub.id;
+    }
+  }
+}

package/src/meta-serialization/format/ft-json-meta-serialization.ts

@@ -0,0 +1,288 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/restrict-plus-operands */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { DotNetLocaleSettings } from '@pbkware/dot-net-date-number-formatting';
+import { FtBooleanMetaField } from '../../meta/fields/ft-boolean-meta-field.js';
+import { FtDateTimeMetaField } from '../../meta/fields/ft-date-time-meta-field.js';
+import { FtDecimalMetaField } from '../../meta/fields/ft-decimal-meta-field.js';
+import { FtFloatMetaField } from '../../meta/fields/ft-float-meta-field.js';
+import { FtIntegerMetaField } from '../../meta/fields/ft-integer-meta-field.js';
+import { FtMetaField } from '../../meta/fields/ft-meta-field.js';
+import { FtStringMetaField } from '../../meta/fields/ft-string-meta-field.js';
+import { FtMeta } from '../../meta/ft-meta.js';
+import { DataTypeMetaSerialization } from '../types/enums/data-type-meta-serialisation.js';
+import { EndOfLineAutoWriteTypeMetaSerialization } from '../types/enums/end-of-line-auto-write-type-meta-serialization.js';
+import { EndOfLineTypeMetaSerialization } from '../types/enums/end-of-line-type-meta-serialization.js';
+import { HeadingConstraintMetaSerialization } from '../types/enums/heading-constraint-meta-serialization.js';
+import { LastLineEndedTypeMetaSerialization } from '../types/enums/last-line-ended-type-meta-serialization.js';
+import { PadAlignmentMetaSerialization } from '../types/enums/pad-alignment-meta-serialization.js';
+import { PadCharTypeMetaSerialization } from '../types/enums/pad-char-type-meta-serialization.js';
+import { QuotedTypeMetaSerialization } from '../types/enums/quoted-type-meta-serialization.js';
+import { TruncateTypeMetaSerialization } from '../types/enums/truncate-type-meta-serialization.js';
+import { FtMetaSerializerOptions } from './meta-serializer-options.js';
+
+/**
+ * Serializes and deserializes FtMeta to/from JSON format.
+ * This provides a simpler alternative to XML serialization.
+ * @public
+ */
+export class FtJsonMetaSerialization {
+  /**
+   * Serialize an FtMeta object to JSON string.
+   */
+  serialize(meta: FtMeta, _options?: FtMetaSerializerOptions): string {
+    const obj: any = {
+      culture: meta.culture.name,
+      delimiterChar: meta.delimiterChar,
+      quoteChar: meta.quoteChar,
+      lineCommentChar: meta.lineCommentChar,
+      endOfLineType: EndOfLineTypeMetaSerialization.serialize(meta.endOfLineType),
+      endOfLineChar: meta.endOfLineChar,
+      endOfLineAutoWriteType: EndOfLineAutoWriteTypeMetaSerialization.serialize(meta.endOfLineAutoWriteType),
+      lastLineEndedType: LastLineEndedTypeMetaSerialization.serialize(meta.lastLineEndedType),
+      allowEndOfLineCharInQuotes: meta.allowEndOfLineCharInQuotes,
+      ignoreBlankLines: meta.ignoreBlankLines,
+      ignoreExtraChars: meta.ignoreExtraChars,
+      allowIncompleteRecords: meta.allowIncompleteRecords,
+      stuffedEmbeddedQuotes: meta.stuffedEmbeddedQuotes,
+      substitutionsEnabled: meta.substitutionsEnabled,
+      substitutionChar: meta.substitutionChar,
+      headingLineCount: meta.headingLineCount,
+      mainHeadingLineIndex: meta.mainHeadingLineIndex,
+      headingConstraint: HeadingConstraintMetaSerialization.serialize(meta.headingConstraint, undefined),
+      headingQuotedType: QuotedTypeMetaSerialization.serialize(meta.headingQuotedType, true, undefined),
+      headingAlwaysWriteOptionalQuote: meta.headingAlwaysWriteOptionalQuote,
+      headingWritePrefixSpace: meta.headingWritePrefixSpace,
+      headingPadAlignment: PadAlignmentMetaSerialization.serialize(meta.headingPadAlignment, true, undefined),
+      headingPadCharType: PadCharTypeMetaSerialization.serialize(meta.headingPadCharType, true, undefined),
+      headingPadChar: meta.headingPadChar,
+      headingTruncateType: TruncateTypeMetaSerialization.serialize(meta.headingTruncateType, true, undefined),
+      headingTruncateChar: meta.headingTruncateChar,
+      headingEndOfValueChar: meta.headingEndOfValueChar,
+    };
+
+    // Serialize fields
+    const fields: any[] = [];
+    for (let i = 0; i < meta.fieldList.count; i++) {
+      const field = meta.fieldList.get(i);
+      fields.push(this.serializeField(field, meta));
+    }
+    obj.fields = fields;
+
+    // Serialize substitutions
+    const substitutions: any[] = [];
+    for (let i = 0; i < meta.substitutionList.count; i++) {
+      const sub = meta.substitutionList.get(i);
+      substitutions.push({
+        token: sub.token,
+        value: sub.value,
+        type: sub.type,
+      });
+    }
+    obj.substitutions = substitutions;
+
+    // Serialize sequences (simplified - just names and root status)
+    const sequences: any[] = [];
+    for (let i = 0; i < meta.sequenceList.count; i++) {
+      const seq = meta.sequenceList.get(i);
+      const seqObj: any = {
+        name: seq.name,
+        root: seq.root,
+      };
+
+      // Serialize items (field references)
+      const items: any[] = [];
+      for (let j = 0; j < seq.itemList.count; j++) {
+        const item = seq.itemList.get(j);
+        // Store field ID or index to reconstruct later
+        const field = item.field;
+        items.push({
+          fieldId: field.id,
+          fieldName: field.name,
+        });
+      }
+      seqObj.items = items;
+
+      sequences.push(seqObj);
+    }
+    obj.sequences = sequences;
+
+    return JSON.stringify(obj, null, 2);
+  }
+
+  /**
+   * Deserialize JSON string to an FtMeta object.
+   */
+  deserialize(json: string, _warnings?: string[]): FtMeta {
+    const warnings = new Array<string>();
+    const obj = JSON.parse(json) as Record<string, any>;
+    const meta = new FtMeta();
+
+    // Deserialize core properties
+    if (obj.culture) {
+      // Try to set locale from culture name
+      try {
+        meta.culture = DotNetLocaleSettings.createInvariant(); // Keep default if not parseable
+      } catch {
+        // Ignore culture parsing errors
+      }
+    }
+    meta.delimiterChar = obj.delimiterChar;
+    meta.quoteChar = obj.quoteChar;
+    meta.lineCommentChar = obj.lineCommentChar;
+    meta.endOfLineType = EndOfLineTypeMetaSerialization.deserialize(obj.endOfLineType, warnings);
+    meta.endOfLineChar = obj.endOfLineChar;
+    meta.endOfLineAutoWriteType = EndOfLineAutoWriteTypeMetaSerialization.deserialize(obj.endOfLineAutoWriteType, warnings);
+    meta.lastLineEndedType = LastLineEndedTypeMetaSerialization.deserialize(obj.lastLineEndedType, warnings);
+    meta.allowEndOfLineCharInQuotes = obj.allowEndOfLineCharInQuotes;
+    meta.ignoreBlankLines = obj.ignoreBlankLines;
+    meta.ignoreExtraChars = obj.ignoreExtraChars;
+    meta.allowIncompleteRecords = obj.allowIncompleteRecords;
+    meta.stuffedEmbeddedQuotes = obj.stuffedEmbeddedQuotes;
+    meta.substitutionsEnabled = obj.substitutionsEnabled;
+    meta.substitutionChar = obj.substitutionChar;
+    meta.headingLineCount = obj.headingLineCount;
+    meta.mainHeadingLineIndex = obj.mainHeadingLineIndex;
+    meta.headingConstraint = HeadingConstraintMetaSerialization.deserialize(obj.headingConstraint, undefined, warnings);
+    meta.headingQuotedType = QuotedTypeMetaSerialization.deserialize(obj.headingQuotedType, true, undefined, warnings);
+    meta.headingAlwaysWriteOptionalQuote = obj.headingAlwaysWriteOptionalQuote;
+    meta.headingWritePrefixSpace = obj.headingWritePrefixSpace;
+    meta.headingPadAlignment = PadAlignmentMetaSerialization.deserialize(obj.headingPadAlignment, true, undefined, warnings);
+    meta.headingPadCharType = PadCharTypeMetaSerialization.deserialize(obj.headingPadCharType, true, undefined, warnings);
+    meta.headingPadChar = obj.headingPadChar;
+    meta.headingTruncateType = TruncateTypeMetaSerialization.deserialize(obj.headingTruncateType, true, undefined, warnings);
+    meta.headingTruncateChar = obj.headingTruncateChar;
+    meta.headingEndOfValueChar = obj.headingEndOfValueChar;
+
+    // Deserialize fields
+    if (obj.fields) {
+      for (const fieldObj of obj.fields) {
+        const dataType = DataTypeMetaSerialization.deserialize(fieldObj.dataType, warnings);
+        const field = meta.fieldList.new(dataType);
+        this.deserializeFieldProperties(field, fieldObj, meta, warnings);
+      }
+    }
+
+    // Deserialize substitutions
+    if (obj.substitutions) {
+      for (const subObj of obj.substitutions) {
+        const sub = meta.substitutionList.new(subObj.type, subObj.token, subObj.value);
+      }
+    }
+
+    // Deserialize sequences
+    if (obj.sequences) {
+      for (const seqObj of obj.sequences) {
+        const sequence = meta.sequenceList.new();
+        sequence.name = seqObj.name;
+        sequence.root = seqObj.root;
+
+        if (seqObj.items) {
+          for (const itemObj of seqObj.items) {
+            // Find field by name first (more reliable), then by ID
+            let field: FtMetaField | undefined;
+            if (itemObj.fieldName) {
+              field = meta.fieldList.find(itemObj.fieldName);
+            } else if (itemObj.fieldId !== undefined && itemObj.fieldId !== 0) {
+              field = meta.fieldList.findById(itemObj.fieldId);
+            }
+            if (field !== undefined) {
+              const item = sequence.itemList.new(field);
+            } else {
+              warnings.push(`Field for sequence item not found: ${itemObj.fieldName || 'ID ' + itemObj.fieldId}`);
+            }
+          }
+        }
+      }
+    }
+
+    return meta;
+  }
+
+  private serializeField(field: FtMetaField, _meta: FtMeta): Record<string, any> {
+    // some meta root properties are default for their corresponding field property
+    const obj: Record<string, any> = {
+      id: field.id,
+      name: field.name,
+      dataType: DataTypeMetaSerialization.serialize(field.dataType),
+      headings: field.headings,
+      fixedWidth: field.fixedWidth,
+      width: field.width,
+      constant: field.constant,
+      null: field.null,
+      valueQuotedType: QuotedTypeMetaSerialization.serialize(field.valueQuotedType, false, undefined),
+      valueAlwaysWriteOptionalQuote: field.valueAlwaysWriteOptionalQuote,
+      valueWritePrefixSpace: field.valueWritePrefixSpace,
+      valuePadAlignment: PadAlignmentMetaSerialization.serialize(field.valuePadAlignment, false, undefined),
+      valuePadCharType: PadCharTypeMetaSerialization.serialize(field.valuePadCharType, false, undefined),
+      valuePadChar: field.valuePadChar,
+      valueTruncateType: TruncateTypeMetaSerialization.serialize(field.valueTruncateType, false, undefined),
+      valueTruncateChar: field.valueTruncateChar,
+      valueEndOfValueChar: field.valueEndOfValueChar,
+    };
+
+    // Type-specific fields
+    if (field instanceof FtStringMetaField) {
+      // String fields have no additional properties
+    } else if (field instanceof FtBooleanMetaField) {
+      obj.styles = field.styles;
+      obj.trueText = field.trueText;
+      obj.falseText = field.falseText;
+    } else if (field instanceof FtIntegerMetaField || field instanceof FtFloatMetaField || field instanceof FtDecimalMetaField) {
+      obj.style = field.styles;
+      obj.format = field.format;
+    } else if (field instanceof FtDateTimeMetaField) {
+      obj.style = field.styles;
+      obj.format = field.format;
+    }
+
+    return obj;
+  }
+
+  private deserializeFieldProperties(field: FtMetaField, obj: Record<string, any>, meta: FtMeta, warnings: string[]): void {
+    // meta already has root properties deserialized, so can be used when root property is default
+    field.name = obj.name;
+    field.headings = obj.headings || [];
+    field.fixedWidth = obj.fixedWidth;
+    field.width = obj.width;
+    field.constant = obj.constant;
+    field.null = obj.null;
+    field.valueQuotedType = QuotedTypeMetaSerialization.deserialize(obj.valueQuotedType, false, undefined, warnings);
+    field.valueAlwaysWriteOptionalQuote = obj.valueAlwaysWriteOptionalQuote;
+    field.valueWritePrefixSpace = obj.valueWritePrefixSpace;
+    field.valuePadAlignment = PadAlignmentMetaSerialization.deserialize(obj.valuePadAlignment, false, undefined, warnings);
+    field.valuePadCharType = PadCharTypeMetaSerialization.deserialize(obj.valuePadCharType, false, undefined, warnings);
+    field.valuePadChar = obj.valuePadChar;
+    field.valueTruncateType = TruncateTypeMetaSerialization.deserialize(obj.valueTruncateType, false, undefined, warnings);
+    field.valueTruncateChar = obj.valueTruncateChar;
+    field.valueEndOfValueChar = obj.valueEndOfValueChar;
+
+    // Type-specific properties
+    if (field instanceof FtBooleanMetaField && obj.styles !== undefined) {
+      if (obj.styles) field.styles = obj.styles;
+      if (obj.trueText) field.trueText = obj.trueText;
+      if (obj.falseText) field.falseText = obj.falseText;
+    } else if (field instanceof FtIntegerMetaField || field instanceof FtFloatMetaField || field instanceof FtDecimalMetaField) {
+      if (obj.styles) field.styles = obj.styles;
+      if (obj.format) field.format = obj.format;
+    } else if (field instanceof FtDateTimeMetaField) {
+      if (obj.styles) field.styles = obj.styles;
+      if (obj.format) field.format = obj.format;
+    }
+  }
+}
+
+/** @public */
+export namespace FtJsonMetaSerialization {
+  export function serialize(meta: FtMeta, options?: FtMetaSerializerOptions): string {
+    const serializer = new FtJsonMetaSerialization();
+    return serializer.serialize(meta, options);
+  }
+
+  export function deserialize(json: string, warnings?: string[]): FtMeta {
+    const deserializer = new FtJsonMetaSerialization();
+    return deserializer.deserialize(json, warnings);
+  }
+}