@pbkware/fielded-text-web 0.1.0

package/src/meta-serialization/types/date-time-meta-serialization.ts

@@ -0,0 +1,220 @@
+import { parseIntStrict } from '@pbkware/js-utils';
+import { FtMetaDefaults } from '../../meta/ft-meta-defaults.js';
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class DateTimeMetaSerialization {
+  static serialize(date: Date, defaultValue: Date): string | undefined {
+    if (date.getTime() === defaultValue.getTime()) {
+      return undefined; // Default value
+    } else {
+      const year = date.getFullYear();
+      const month = date.getMonth() + 1;
+      const day = date.getDate();
+      const hour = date.getHours();
+      const minute = date.getMinutes();
+      const second = date.getSeconds();
+      const millisecond = date.getMilliseconds();
+
+      let result = year.toString().padStart(4, '0') + month.toString().padStart(2, '0') + day.toString().padStart(2, '0');
+
+      if (hour !== 0 || minute !== 0 || second !== 0 || millisecond !== 0) {
+        result += hour.toString().padStart(2, '0') + minute.toString().padStart(2, '0') + second.toString().padStart(2, '0');
+        if (millisecond !== 0) {
+          result += FtMetaDefaults.DateTimeField.TimeAndFractionSeparatorChar + millisecond.toString().padStart(3, '0');
+        }
+      }
+
+      return result;
+    }
+  }
+
+  static deserialize(value: unknown, defaultValue: Date, warnings: string[]): Date {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`DateTime: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const trimmedValue = value.trim();
+        const length = trimmedValue.length;
+        if (length < FtMetaDefaults.DateTimeField.TimeFormatLength) {
+          warnings.push(`DateTime: Too short: ${value}`);
+          return defaultValue;
+        } else {
+          if (length === FtMetaDefaults.DateTimeField.TimeFormatLength) {
+            return DateTimeMetaSerialization.deserializeTime(trimmedValue, false, defaultValue, warnings);
+          } else {
+            if (trimmedValue[FtMetaDefaults.DateTimeField.TimeFormatLength] === FtMetaDefaults.DateTimeField.TimeAndFractionSeparatorChar) {
+              return DateTimeMetaSerialization.deserializeTime(trimmedValue, true, defaultValue, warnings);
+            } else {
+              if (length === FtMetaDefaults.DateTimeField.DateFormatLength) {
+                return DateTimeMetaSerialization.deserializeDate(trimmedValue, defaultValue, warnings);
+              } else {
+                if (length === FtMetaDefaults.DateTimeField.DateTimeFormatLength) {
+                  return DateTimeMetaSerialization.deserializeDateTime(trimmedValue, false, defaultValue, warnings);
+                } else {
+                  if (
+                    length > FtMetaDefaults.DateTimeField.DateTimeFormatLength &&
+                    trimmedValue[FtMetaDefaults.DateTimeField.DateTimeFormatLength] === FtMetaDefaults.DateTimeField.TimeAndFractionSeparatorChar
+                  ) {
+                    return DateTimeMetaSerialization.deserializeDateTime(trimmedValue, true, defaultValue, warnings);
+                  } else {
+                    warnings.push(`DateTime: Invalid format: ${value}`);
+                    return defaultValue;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private static deserializeYearMonthDay(text: string, warnings: string[]): YearMonthDay | undefined {
+    const year = parseIntStrict(text.substring(0, 4));
+    if (year === undefined || Number.isNaN(year)) {
+      warnings.push(`DateTime: Invalid year: ${text}`);
+    } else {
+      if (year < 1 || year > 9999) {
+        warnings.push(`DateTime: Year out of range: ${text}`);
+      } else {
+        const month = parseIntStrict(text.substring(4, 6));
+        if (month === undefined || Number.isNaN(month)) {
+          warnings.push(`DateTime: Invalid month: ${text}`);
+        } else {
+          if (month < 1 || month > 12) {
+            warnings.push(`DateTime: Month out of range: ${text}`);
+          } else {
+            const day = parseIntStrict(text.substring(6, 8));
+            if (day === undefined || Number.isNaN(day)) {
+              warnings.push(`DateTime: Invalid day: ${text}`);
+            } else {
+              if (day < 1 || day > 31) {
+                warnings.push(`DateTime: Day out of range: ${text}`);
+              } else {
+                return { year, month, day };
+              }
+            }
+          }
+        }
+      }
+    }
+    return undefined;
+  }
+
+  private static deserializeHourMinuteSecond(text: string, hasFraction: boolean, warnings: string[]): HourMinuteSecondMilli | undefined {
+    const hour = parseIntStrict(text.substring(0, 2));
+    if (hour === undefined || Number.isNaN(hour)) {
+      warnings.push(`DateTime: Invalid hour: ${text}`);
+    } else {
+      if (hour < 0 || hour > 23) {
+        warnings.push(`DateTime: Hour out of range: ${text}`);
+      } else {
+        const minute = parseIntStrict(text.substring(2, 4));
+        if (minute === undefined || Number.isNaN(minute)) {
+          warnings.push(`DateTime: Invalid minute: ${text}`);
+        } else {
+          if (minute < 0 || minute > 59) {
+            warnings.push(`DateTime: Minute out of range: ${text}`);
+          } else {
+            const second = parseIntStrict(text.substring(4, 6));
+            if (second === undefined || Number.isNaN(second)) {
+              warnings.push(`DateTime: Invalid second: ${text}`);
+            } else {
+              if (second < 0 || second > 59) {
+                warnings.push(`DateTime: Second out of range: ${text}`);
+              } else {
+                if (!hasFraction) {
+                  return { hour, minute, second, millisecond: 0 };
+                } else {
+                  const fractionText = text.substring(FtMetaDefaults.DateTimeField.TimeFormatLength + 1);
+                  const fractionLength = fractionText.length;
+                  if (fractionLength > FtMetaDefaults.DateTimeField.MaxFractionLength) {
+                    warnings.push(`DateTime: Too long fraction: ${text}`);
+                  } else {
+                    const fractionValue = parseIntStrict(fractionText);
+                    if (fractionValue === undefined || Number.isNaN(fractionValue)) {
+                      warnings.push(`DateTime: Invalid fraction: ${text}`);
+                    } else {
+                      const millisecond = Math.round(fractionValue * Math.pow(10, 3 - fractionLength));
+                      return { hour, minute, second, millisecond };
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return undefined;
+  }
+
+  private static deserializeDate(text: string, defaultValue: Date, warnings: string[]): Date {
+    const ymd = this.deserializeYearMonthDay(text, warnings);
+    if (ymd === undefined) {
+      return new Date(defaultValue);
+    } else {
+      let result: Date;
+      try {
+        result = new Date(ymd.year, ymd.month - 1, ymd.day);
+      } catch {
+        warnings.push(`DateTime: Invalid date: ${text}`);
+        return new Date(defaultValue);
+      }
+      return result;
+    }
+  }
+
+  private static deserializeTime(text: string, hasFraction: boolean, defaultValue: Date, warnings: string[]): Date {
+    const hms = this.deserializeHourMinuteSecond(text, hasFraction, warnings);
+    if (hms === undefined) {
+      return new Date(defaultValue);
+    } else {
+      let result: Date;
+      try {
+        result = new Date(1, 0, 1, hms.hour, hms.minute, hms.second, hms.millisecond);
+      } catch {
+        warnings.push(`DateTime: Invalid time: ${text}`);
+        return new Date(defaultValue);
+      }
+      return result;
+    }
+  }
+
+  private static deserializeDateTime(text: string, hasFraction: boolean, defaultValue: Date, warnings: string[]): Date {
+    const ymd = this.deserializeYearMonthDay(text, warnings);
+    if (ymd === undefined) {
+      return new Date(defaultValue);
+    } else {
+      const hms = this.deserializeHourMinuteSecond(text, hasFraction, warnings);
+      if (hms === undefined) {
+        return new Date(defaultValue);
+      } else {
+        let result: Date;
+        try {
+          result = new Date(ymd.year, ymd.month - 1, ymd.day, hms.hour, hms.minute, hms.second, hms.millisecond);
+        } catch {
+          warnings.push(`DateTime: Invalid date-time: ${text}`);
+          return new Date(defaultValue);
+        }
+        return result;
+      }
+    }
+  }
+}
+
+interface YearMonthDay {
+  year: number;
+  month: number;
+  day: number;
+}
+
+interface HourMinuteSecondMilli {
+  hour: number;
+  minute: number;
+  second: number;
+  millisecond: number;
+}

package/src/meta-serialization/types/decimal-meta-serialization.ts

@@ -0,0 +1,13 @@
+import { FloatMetaSerialization } from './float-meta-serialization.js';
+
+// Use same serialization as Float until JavaScript has a separate Decimal type
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class DecimalMetaSerialization {
+  static serialize(value: number, defaultValue: number): string | undefined {
+    return FloatMetaSerialization.serialize(value, defaultValue);
+  }
+
+  static deserialize(value: unknown, defaultValue: number, warnings: string[]): number {
+    return FloatMetaSerialization.deserialize(value, defaultValue, warnings);
+  }
+}

package/src/meta-serialization/types/enums/data-type-meta-serialisation.ts

@@ -0,0 +1,52 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtDataType } from '../../../types/enums/ft-data-type.js';
+
+export namespace DataTypeMetaSerialization {
+  export const defaultValue = FtMetaDefaults.Field.DataType;
+
+  export function serialize(value: FtDataType): string | undefined {
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, warnings: string[]): FtDataType {
+    if (typeof value === 'undefined') {
+      return defaultValue; // Default value
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`DataType: Type: ${typeof value}`);
+        return defaultValue; // Default value
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`DataType: Value: ${value}`);
+          return defaultValue; // Default value
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtDataType, string> = {
+  [FtDataType.String]: 'String',
+  [FtDataType.Boolean]: 'Boolean',
+  [FtDataType.Integer]: 'Integer',
+  [FtDataType.Float]: 'Float',
+  [FtDataType.Decimal]: 'Decimal',
+  [FtDataType.DateTime]: 'DateTime',
+};
+
+const deserializeMap: Record<string, FtDataType> = {
+  String: FtDataType.String,
+  Boolean: FtDataType.Boolean,
+  Integer: FtDataType.Integer,
+  Float: FtDataType.Float,
+  Decimal: FtDataType.Decimal,
+  DateTime: FtDataType.DateTime,
+};

package/src/meta-serialization/types/enums/end-of-line-auto-write-type-meta-serialization.ts

@@ -0,0 +1,47 @@
+import { FtEndOfLineAutoWriteType } from '../../../types/enums/ft-end-of-line-auto-write-type.js';
+
+export namespace EndOfLineAutoWriteTypeMetaSerialization {
+  export const defaultValue = FtEndOfLineAutoWriteType.CrLf;
+
+  export function serialize(value: FtEndOfLineAutoWriteType): string | undefined {
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, warnings: string[]): FtEndOfLineAutoWriteType {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`EndOfLineAutoWriteType: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`EndOfLineAutoWriteType: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtEndOfLineAutoWriteType, string> = {
+  [FtEndOfLineAutoWriteType.CrLf]: 'CrLf',
+  [FtEndOfLineAutoWriteType.Cr]: 'Cr',
+  [FtEndOfLineAutoWriteType.Lf]: 'Lf',
+  [FtEndOfLineAutoWriteType.Local]: 'Local',
+};
+
+const deserializeMap: Record<string, FtEndOfLineAutoWriteType> = {
+  CrLf: FtEndOfLineAutoWriteType.CrLf,
+  Cr: FtEndOfLineAutoWriteType.Cr,
+  Lf: FtEndOfLineAutoWriteType.Lf,
+  Local: FtEndOfLineAutoWriteType.Local,
+};

package/src/meta-serialization/types/enums/end-of-line-type-meta-serialization.ts

@@ -0,0 +1,46 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtEndOfLineType } from '../../../types/enums/ft-end-of-line-type.js';
+
+export namespace EndOfLineTypeMetaSerialization {
+  export const defaultValue = FtMetaDefaults.Root.EndOfLineType;
+
+  export function serialize(value: FtEndOfLineType): string | undefined {
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, warnings: string[]): FtEndOfLineType {
+    if (typeof value === 'undefined') {
+      return defaultValue; // Default value
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`EndOfLineType: Type: ${typeof value}`);
+        return defaultValue; // Default value
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`EndOfLineType: Value: ${value}`);
+          return defaultValue; // Default value
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtEndOfLineType, string> = {
+  [FtEndOfLineType.Auto]: 'Auto',
+  [FtEndOfLineType.Char]: 'Char',
+  [FtEndOfLineType.CrLf]: 'CrLf',
+};
+
+const deserializeMap: Record<string, FtEndOfLineType> = {
+  Auto: FtEndOfLineType.Auto,
+  Char: FtEndOfLineType.Char,
+  CrLf: FtEndOfLineType.CrLf,
+};

package/src/meta-serialization/types/enums/heading-constraint-meta-serialization.ts

@@ -0,0 +1,52 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtHeadingConstraint } from '../../../types/enums/ft-heading-constraint.js';
+
+export namespace HeadingConstraintMetaSerialization {
+  export const headingDefaultValue = FtMetaDefaults.Root.HeadingConstraint;
+
+  export function serialize(value: FtHeadingConstraint, overridingHeadingDefault: FtHeadingConstraint | undefined): string | undefined {
+    const defaultValue = overridingHeadingDefault ?? headingDefaultValue;
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, overridingHeadingDefault: FtHeadingConstraint | undefined, warnings: string[]): FtHeadingConstraint {
+    const defaultValue = overridingHeadingDefault ?? headingDefaultValue;
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`HeadingConstraint: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`HeadingConstraint: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtHeadingConstraint, string> = {
+  [FtHeadingConstraint.None]: 'None',
+  [FtHeadingConstraint.AllConstant]: 'AllConstant',
+  [FtHeadingConstraint.MainConstant]: 'MainConstant',
+  [FtHeadingConstraint.NameConstant]: 'NameConstant',
+  [FtHeadingConstraint.NameIsMain]: 'NameIsMain',
+};
+
+const deserializeMap: Record<string, FtHeadingConstraint> = {
+  None: FtHeadingConstraint.None,
+  AllConstant: FtHeadingConstraint.AllConstant,
+  MainConstant: FtHeadingConstraint.MainConstant,
+  NameConstant: FtHeadingConstraint.NameConstant,
+  NameIsMain: FtHeadingConstraint.NameIsMain,
+};

package/src/meta-serialization/types/enums/last-line-ended-type-meta-serialization.ts

@@ -0,0 +1,45 @@
+import { FtLastLineEndedType } from '../../../types/enums/ft-last-line-ended-type.js';
+
+export namespace LastLineEndedTypeMetaSerialization {
+  export const defaultValue = FtLastLineEndedType.Never;
+
+  export function serialize(value: FtLastLineEndedType): string | undefined {
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, warnings: string[]): FtLastLineEndedType {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`LastLineEndedType: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`LastLineEndedType: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtLastLineEndedType, string> = {
+  [FtLastLineEndedType.Never]: 'Never',
+  [FtLastLineEndedType.Always]: 'Always',
+  [FtLastLineEndedType.Optional]: 'Optional',
+};
+
+const deserializeMap: Record<string, FtLastLineEndedType> = {
+  Never: FtLastLineEndedType.Never,
+  Always: FtLastLineEndedType.Always,
+  Optional: FtLastLineEndedType.Optional,
+};

package/src/meta-serialization/types/enums/meta-element-type-meta-serialization.ts

@@ -0,0 +1,36 @@
+import { Err, Ok, Result } from '@pbkware/js-utils';
+import { FtMetaElementType } from '../../../types/enums/ft-meta-element-type.js';
+
+export namespace MetaElementTypeMetaSerialization {
+  export function serialize(value: FtMetaElementType): string {
+    return serializeMap[value];
+  }
+
+  export function deserialize(value: string): Result<FtMetaElementType> {
+    const deserializedValue = deserializeMap[value.trim()];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (deserializedValue === undefined) {
+      return new Err(`MetaElementType: Value: ${value}`);
+    } else {
+      return new Ok(deserializedValue);
+    }
+  }
+}
+
+const serializeMap: Record<FtMetaElementType, string> = {
+  [FtMetaElementType.FieldedText]: 'FieldedText',
+  [FtMetaElementType.Substitution]: 'Substitution',
+  [FtMetaElementType.Field]: 'Field',
+  [FtMetaElementType.Sequence]: 'Sequence',
+  [FtMetaElementType.SequenceItem]: 'Item',
+  [FtMetaElementType.SequenceRedirect]: 'Redirect',
+};
+
+const deserializeMap: Record<string, FtMetaElementType> = {
+  FieldedText: FtMetaElementType.FieldedText,
+  Substitution: FtMetaElementType.Substitution,
+  Field: FtMetaElementType.Field,
+  Sequence: FtMetaElementType.Sequence,
+  Item: FtMetaElementType.SequenceItem,
+  Redirect: FtMetaElementType.SequenceRedirect,
+};

package/src/meta-serialization/types/enums/pad-alignment-meta-serialization.ts

@@ -0,0 +1,54 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtPadAlignment } from '../../../types/enums/ft-pad-alignment.js';
+
+export namespace PadAlignmentMetaSerialization {
+  export const headingDefaultValue = FtMetaDefaults.Root.HeadingPadAlignment;
+  export const valueDefaultValue = FtMetaDefaults.Field.ValuePadAlignment;
+
+  export function serialize(value: FtPadAlignment, isHeading: boolean, overridingHeadingDefault: FtPadAlignment | undefined): string | undefined {
+    const defaultValue = isHeading ? (overridingHeadingDefault ?? headingDefaultValue) : valueDefaultValue;
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(
+    value: unknown,
+    isHeading: boolean,
+    overridingHeadingDefault: FtPadAlignment | undefined,
+    warnings: string[],
+  ): FtPadAlignment {
+    const defaultValue = isHeading ? (overridingHeadingDefault ?? headingDefaultValue) : valueDefaultValue;
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`PadAlignment: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`PadAlignment: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtPadAlignment, string> = {
+  [FtPadAlignment.Auto]: 'Auto',
+  [FtPadAlignment.Left]: 'Left',
+  [FtPadAlignment.Right]: 'Right',
+};
+
+const deserializeMap: Record<string, FtPadAlignment> = {
+  Auto: FtPadAlignment.Auto,
+  Left: FtPadAlignment.Left,
+  Right: FtPadAlignment.Right,
+};

package/src/meta-serialization/types/enums/pad-char-type-meta-serialization.ts

@@ -0,0 +1,54 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtPadCharType } from '../../../types/enums/ft-pad-char-type.js';
+
+export namespace PadCharTypeMetaSerialization {
+  export const headingDefaultValue = FtMetaDefaults.Root.HeadingPadCharType;
+  export const valueDefaultValue = FtMetaDefaults.Field.ValuePadCharType;
+
+  export function serialize(value: FtPadCharType, isHeading: boolean, overridingHeadingDefault: FtPadCharType | undefined): string | undefined {
+    const defaultValue = isHeading ? (overridingHeadingDefault ?? headingDefaultValue) : valueDefaultValue;
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(
+    value: unknown,
+    isHeading: boolean,
+    overridingHeadingDefault: FtPadCharType | undefined,
+    warnings: string[],
+  ): FtPadCharType {
+    const defaultValue = isHeading ? (overridingHeadingDefault ?? headingDefaultValue) : valueDefaultValue;
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`PadCharType: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`PadCharType: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtPadCharType, string> = {
+  [FtPadCharType.Auto]: 'Auto',
+  [FtPadCharType.Specified]: 'Specified',
+  [FtPadCharType.EndOfValue]: 'EndOfValue',
+};
+
+const deserializeMap: Record<string, FtPadCharType> = {
+  Auto: FtPadCharType.Auto,
+  Specified: FtPadCharType.Specified,
+  EndOfValue: FtPadCharType.EndOfValue,
+};

package/src/meta-serialization/types/enums/quoted-type-meta-serialization.ts

@@ -0,0 +1,54 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtQuotedType } from '../../../types/enums/ft-quoted-type.js';
+
+export namespace QuotedTypeMetaSerialization {
+  export const headingDefaultValue = FtMetaDefaults.Root.HeadingQuotedType;
+  export const valueDefaultValue = FtMetaDefaults.Field.ValueQuotedType;
+
+  export function serialize(value: FtQuotedType, isHeading: boolean, overridingHeadingDefault: FtQuotedType | undefined): string | undefined {
+    const defaultValue = isHeading ? (overridingHeadingDefault ?? headingDefaultValue) : valueDefaultValue;
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(
+    value: unknown,
+    isHeading: boolean,
+    overridingHeadingDefault: FtQuotedType | undefined,
+    warnings: string[],
+  ): FtQuotedType {
+    const defaultValue = isHeading ? (overridingHeadingDefault ?? headingDefaultValue) : valueDefaultValue;
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`QuotedType: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const result = deserializeMap[value.trim()];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (result === undefined) {
+          warnings.push(`QuotedType: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtQuotedType, string> = {
+  [FtQuotedType.Never]: 'Never',
+  [FtQuotedType.Always]: 'Always',
+  [FtQuotedType.Optional]: 'Optional',
+};
+
+const deserializeMap: Record<string, FtQuotedType> = {
+  Never: FtQuotedType.Never,
+  Always: FtQuotedType.Always,
+  Optional: FtQuotedType.Optional,
+};