@pbkware/fielded-text-web 0.1.0

package/src/meta-serialization/format/meta-serializer-options.ts

@@ -0,0 +1,21 @@
+/**
+ * Options for serialization formatting.
+ * @public
+ */
+export interface FtMetaSerializerOptions {
+  explicitIndices?: boolean; // Whether to include explicit index attributes for fields.
+  indent?: boolean;
+  indentChars?: string;
+  newLineOnAttributes?: boolean;
+}
+
+/**
+ * Default values for meta serialization formatting.
+ * @public
+ */
+export namespace FtMetaSerializerOptions {
+  export const DEFAULT_EXPLICIT_INDICES = false;
+  export const DEFAULT_INDENT = true;
+  export const DEFAULT_INDENT_CHARS = '  ';
+  export const DEFAULT_NEW_LINE_ON_ATTRIBUTES = false;
+}

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

@@ -0,0 +1,60 @@
+import { FtMeta } from '../meta/ft-meta.js';
+import { FtMetaSerializationFormat } from '../types/enums/ft-meta-serialization-format.js';
+import { FtJsonMetaSerialization } from './format/ft-json-meta-serialization.js';
+import { FtXmlMetaSerialization } from './format/ft-xml-meta-serialization.js';
+import { FtMetaSerializerOptions } from './format/meta-serializer-options.js';
+
+/**
+ * API for serializing and deserializing FtMeta objects.
+ * Provides a unified interface for both XML and JSON formats.
+ * @public
+ */
+export class FtMetaSerialization {
+  /**
+   * Deserialize an FtMeta object from a string.
+   * @param content - The serialized meta content (XML or JSON)
+   * @param format - The format of the content (default: auto-detect)
+   * @param warnings - Optional array to collect warnings during deserialization
+   * @returns The deserialized FtMeta object
+   */
+  deserialize(content: string, warnings?: string[], format?: FtMetaSerializationFormat): FtMeta {
+    if (format === FtMetaSerializationFormat.JSON) {
+      const jsonDeserializer = new FtJsonMetaSerialization();
+      return jsonDeserializer.deserialize(content);
+    } else {
+      // XML deserialization
+      const xmlDeserializer = new FtXmlMetaSerialization();
+      return xmlDeserializer.deserialize(content, warnings);
+    }
+  }
+
+  /**
+   * Serialize an FtMeta object to a string.
+   * @param meta - The FtMeta object to serialize
+   * @param format - The output format (default: XML)
+   * @returns The serialized string
+   */
+  serialize(meta: FtMeta, options?: FtMetaSerializerOptions, format?: FtMetaSerializationFormat): string {
+    if (format === FtMetaSerializationFormat.JSON) {
+      const jsonSerializer = new FtJsonMetaSerialization();
+      return jsonSerializer.serialize(meta);
+    } else {
+      // XML serialization
+      const xmlSerializer = new FtXmlMetaSerialization();
+      return xmlSerializer.serialize(meta, options);
+    }
+  }
+}
+
+/** @public */
+export namespace FtMetaSerialization {
+  export function serialize(meta: FtMeta, options?: FtMetaSerializerOptions, format?: FtMetaSerializationFormat): string {
+    const serialization = new FtMetaSerialization();
+    return serialization.serialize(meta, options, format);
+  }
+
+  export function deserialize(content: string, warnings?: string[], format?: FtMetaSerializationFormat): FtMeta {
+    const serialization = new FtMetaSerialization();
+    return serialization.deserialize(content, warnings, format);
+  }
+}

package/src/meta-serialization/styles/ft-boolean-styles-meta-serialization.ts

@@ -0,0 +1,88 @@
+import { FtBooleanMetaField } from '../../meta/fields/ft-boolean-meta-field.js';
+import { FtBooleanStyles, noneBooleanStyles } from '../../types/enums/ft-boolean-styles.js';
+
+/** @public */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class FtBooleanStylesMetaSerialization {
+  static serialize(styles: FtBooleanStyles): string | undefined {
+    if (styles === FtBooleanMetaField.DEFAULT_STYLES) {
+      return undefined;
+    } else {
+      const result = new Array<string>(booleanStylesMetaInfoCount);
+      let count = 0;
+      for (const metaInfo of booleanStylesMetaInfoArray) {
+        if ((styles & metaInfo.styles) === metaInfo.styles) {
+          result[count++] = metaInfo.metaValue;
+        }
+      }
+      result.length = count;
+      return result.join(',');
+    }
+  }
+
+  static deserialize(value: unknown, warnings: string[]): FtBooleanStyles {
+    if (value === undefined) {
+      return FtBooleanMetaField.DEFAULT_STYLES;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`Boolean styles: Type: ${typeof value}`);
+        return FtBooleanMetaField.DEFAULT_STYLES;
+      } else {
+        const trimmedValue = value.trim();
+        if (trimmedValue.length === 0) {
+          return noneBooleanStyles;
+        } else {
+          let result: FtBooleanStyles = noneBooleanStyles;
+          const lowerCasedValue = trimmedValue.toLowerCase();
+          const styleStringArray = lowerCasedValue.split(',').map((s) => s.trim());
+          for (const styleString of styleStringArray) {
+            for (const metaInfo of booleanStylesMetaInfoArray) {
+              if (styleString === metaInfo.lowerCaseMetaValue) {
+                result |= metaInfo.styles;
+              } else {
+                warnings.push(`Unknown boolean style: '${styleString}'`);
+              }
+            }
+          }
+          return result;
+        }
+      }
+    }
+  }
+}
+
+interface BooleanStylesMetaInfo {
+  styles: FtBooleanStyles;
+  metaValue: string;
+  lowerCaseMetaValue: string;
+}
+
+const ignoreCaseMetaValue = 'IgnoreCase';
+const matchFirstCharOnlyMetaValue = 'MatchFirstCharOnly';
+const ignoreTrailingCharsMetaValue = 'IgnoreTrailingChars';
+const falseIfNotMatchTrueMetaValue = 'FalseIfNotMatchTrue';
+
+const booleanStylesMetaInfoArray: BooleanStylesMetaInfo[] = [
+  {
+    styles: FtBooleanStyles.IgnoreCase,
+    metaValue: ignoreCaseMetaValue,
+    lowerCaseMetaValue: ignoreCaseMetaValue.toLowerCase(),
+  },
+  {
+    styles: FtBooleanStyles.MatchFirstCharOnly,
+    metaValue: matchFirstCharOnlyMetaValue,
+    lowerCaseMetaValue: matchFirstCharOnlyMetaValue.toLowerCase(),
+  },
+  {
+    styles: FtBooleanStyles.IgnoreTrailingChars,
+    metaValue: ignoreTrailingCharsMetaValue,
+    lowerCaseMetaValue: ignoreTrailingCharsMetaValue.toLowerCase(),
+  },
+  {
+    styles: FtBooleanStyles.FalseIfNotMatchTrue,
+    metaValue: falseIfNotMatchTrueMetaValue,
+    lowerCaseMetaValue: falseIfNotMatchTrueMetaValue.toLowerCase(),
+  },
+];
+
+const booleanStylesMetaInfoCount = booleanStylesMetaInfoArray.length;

package/src/meta-serialization/styles/ft-date-time-styles-meta-serialization.ts

@@ -0,0 +1,50 @@
+import { DotNetDateTimeStyles } from '@pbkware/dot-net-date-number-formatting';
+import { FtMetaDefaults } from '../../meta/ft-meta-defaults.js';
+
+/** @public */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class FtDateTimeStylesMetaSerialization {
+  static allowInnerWhiteMetaValue = 'AllowInnerWhite';
+  static allowWhiteSpacesMetaValue = 'AllowWhiteSpaces'; // Not part of standard but supported as includes AllowInnerWhite in Dot Net.
+  static lowerCaseAllowInnerWhiteMetaValue = FtDateTimeStylesMetaSerialization.allowInnerWhiteMetaValue.toLowerCase();
+  static lowerCaseAllowWhiteSpacesMetaValue = FtDateTimeStylesMetaSerialization.allowWhiteSpacesMetaValue.toLowerCase();
+
+  static serialize(styles: DotNetDateTimeStyles): string | undefined {
+    if (styles === FtMetaDefaults.DateTimeField.Styles) {
+      return undefined;
+    } else {
+      if ((styles & DotNetDateTimeStyles.allowInnerWhite) === DotNetDateTimeStyles.allowInnerWhite) {
+        return this.allowInnerWhiteMetaValue;
+      } else {
+        return undefined;
+      }
+    }
+  }
+
+  static deserialize(value: unknown, warnings: string[]): DotNetDateTimeStyles {
+    if (value === undefined) {
+      return FtMetaDefaults.DateTimeField.Styles;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`DateTime styles: Type: ${typeof value}`);
+        return FtMetaDefaults.DateTimeField.Styles;
+      } else {
+        const trimmedValue = value.trim();
+        if (trimmedValue.length === 0) {
+          return DotNetDateTimeStyles.none;
+        } else {
+          const lowerCasedValue = trimmedValue.toLowerCase();
+          const styleStringArray = lowerCasedValue.split(',').map((s) => s.trim());
+          for (const styleString of styleStringArray) {
+            if (styleString === this.lowerCaseAllowInnerWhiteMetaValue || styleString === this.lowerCaseAllowWhiteSpacesMetaValue) {
+              return DotNetDateTimeStyles.allowInnerWhite;
+            } else {
+              warnings.push(`Unrecognized date/time style: ${styleString}`);
+            }
+          }
+          return DotNetDateTimeStyles.none;
+        }
+      }
+    }
+  }
+}

package/src/meta-serialization/styles/ft-number-styles-meta-serialization.ts

@@ -0,0 +1,212 @@
+import { DotNetNumberStyles } from '@pbkware/dot-net-date-number-formatting';
+import { FtMetaDefaults } from '../../meta/ft-meta-defaults.js';
+import { FtDataType, FtNumberDataType } from '../../types/enums/ft-data-type.js';
+import { FtUnreachableCaseError } from '../../types/errors/ft-internal-error.js';
+
+/** @public */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class FtNumberStylesMetaSerialization {
+  static allowInnerWhiteMetaValue = 'AllowInnerWhite';
+  static allowWhiteSpacesMetaValue = 'AllowWhiteSpaces'; // Not part of standard but supported as includes AllowInnerWhite in Dot Net.
+  static lowerCaseAllowInnerWhiteMetaValue = FtNumberStylesMetaSerialization.allowInnerWhiteMetaValue.toLowerCase();
+  static lowerCaseAllowWhiteSpacesMetaValue = FtNumberStylesMetaSerialization.allowWhiteSpacesMetaValue.toLowerCase();
+
+  static serialize(styles: DotNetNumberStyles, dataType: FtNumberDataType): string | undefined {
+    switch (dataType) {
+      case FtDataType.Integer:
+        if (styles === FtMetaDefaults.IntegerField.Styles) {
+          return undefined;
+        }
+        break;
+      case FtDataType.Float:
+        if (styles === FtMetaDefaults.FloatField.Styles) {
+          return undefined;
+        }
+        break;
+      case FtDataType.Decimal:
+        if (styles === FtMetaDefaults.DecimalField.Styles) {
+          return undefined;
+        }
+        break;
+      default:
+        throw new FtUnreachableCaseError('NSMSS33997', dataType);
+    }
+
+    for (const compositeMetaInfo of compositeNumberStylesMetaInfoArray) {
+      if (styles === compositeMetaInfo.styles) {
+        return compositeMetaInfo.metaValue;
+      }
+    }
+
+    const result = new Array<string>(flagNumberStylesMetaInfoCount);
+    let count = 0;
+    for (const flagMetaInfo of flagNumberStylesMetaInfoArray) {
+      if ((styles & flagMetaInfo.styles) === flagMetaInfo.styles) {
+        result[count++] = flagMetaInfo.metaValue;
+      }
+    }
+    result.length = count;
+    return result.join(',');
+  }
+
+  static deserialize(value: unknown, dataType: FtNumberDataType, warnings: string[]): DotNetNumberStyles {
+    if (value === undefined) {
+      return this.getDefaultNumberStyles(dataType);
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`Number styles: Type: ${typeof value}`);
+        return this.getDefaultNumberStyles(dataType);
+      } else {
+        const trimmedValue = value.trim();
+        if (trimmedValue.length === 0) {
+          return DotNetNumberStyles.none;
+        } else {
+          let result: DotNetNumberStyles = DotNetNumberStyles.none;
+          const lowerCasedValue = trimmedValue.toLowerCase();
+          const styleStringArray = lowerCasedValue.split(',').map((s) => s.trim());
+          for (const styleString of styleStringArray) {
+            for (const compositeMetaInfo of compositeNumberStylesMetaInfoArray) {
+              if (styleString === compositeMetaInfo.lowerCaseMetaValue) {
+                result |= compositeMetaInfo.styles;
+                continue;
+              }
+            }
+            for (const flagMetaInfo of flagNumberStylesMetaInfoArray) {
+              if (styleString === flagMetaInfo.lowerCaseMetaValue) {
+                result |= flagMetaInfo.styles;
+                continue;
+              }
+            }
+            warnings.push(`Unrecognized number style: ${styleString}`);
+          }
+          return result;
+        }
+      }
+    }
+  }
+
+  private static getDefaultNumberStyles(dataType: FtNumberDataType): DotNetNumberStyles {
+    switch (dataType) {
+      case FtDataType.Integer:
+        return FtMetaDefaults.IntegerField.Styles;
+      case FtDataType.Float:
+        return FtMetaDefaults.FloatField.Styles;
+      case FtDataType.Decimal:
+        return FtMetaDefaults.DecimalField.Styles;
+      default:
+        throw new FtUnreachableCaseError('NSMSGDNS33999', dataType);
+    }
+  }
+}
+
+interface NumberStylesMetaInfo {
+  styles: DotNetNumberStyles;
+  metaValue: string;
+  lowerCaseMetaValue: string;
+}
+
+const allowLeadingWhiteMetaValue = 'AllowLeadingWhite';
+const allowTrailingWhiteMetaValue = 'AllowTrailingWhite';
+const allowLeadingSignMetaValue = 'AllowLeadingSign';
+const allowTrailingSignMetaValue = 'AllowTrailingSign';
+const allowParenthesesMetaValue = 'AllowParentheses';
+const allowDecimalPointMetaValue = 'AllowDecimalPoint';
+const allowThousandsMetaValue = 'AllowThousands';
+const allowExponentMetaValue = 'AllowExponent';
+const allowCurrencySymbolMetaValue = 'AllowCurrencySymbol';
+const allowHexSpecifierMetaValue = 'AllowHexSpecifier';
+
+const noneMetaValue = 'None';
+const anyMetaValue = 'Any';
+const currencyMetaValue = 'Currency';
+const floatMetaValue = 'Float';
+const hexNumberMetaValue = 'HexNumber';
+const integerMetaValue = 'Integer';
+
+const flagNumberStylesMetaInfoArray: NumberStylesMetaInfo[] = [
+  {
+    styles: DotNetNumberStyles.allowLeadingWhite,
+    metaValue: allowLeadingWhiteMetaValue,
+    lowerCaseMetaValue: allowLeadingWhiteMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowTrailingWhite,
+    metaValue: allowTrailingWhiteMetaValue,
+    lowerCaseMetaValue: allowTrailingWhiteMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowLeadingSign,
+    metaValue: allowLeadingSignMetaValue,
+    lowerCaseMetaValue: allowLeadingSignMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowTrailingSign,
+    metaValue: allowTrailingSignMetaValue,
+    lowerCaseMetaValue: allowTrailingSignMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowParentheses,
+    metaValue: allowParenthesesMetaValue,
+    lowerCaseMetaValue: allowParenthesesMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowDecimalPoint,
+    metaValue: allowDecimalPointMetaValue,
+    lowerCaseMetaValue: allowDecimalPointMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowThousands,
+    metaValue: allowThousandsMetaValue,
+    lowerCaseMetaValue: allowThousandsMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowExponent,
+    metaValue: allowExponentMetaValue,
+    lowerCaseMetaValue: allowExponentMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowCurrencySymbol,
+    metaValue: allowCurrencySymbolMetaValue,
+    lowerCaseMetaValue: allowCurrencySymbolMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.allowHexSpecifier,
+    metaValue: allowHexSpecifierMetaValue,
+    lowerCaseMetaValue: allowHexSpecifierMetaValue.toLowerCase(),
+  },
+];
+
+const flagNumberStylesMetaInfoCount = flagNumberStylesMetaInfoArray.length;
+
+const compositeNumberStylesMetaInfoArray: NumberStylesMetaInfo[] = [
+  {
+    styles: DotNetNumberStyles.none,
+    metaValue: noneMetaValue,
+    lowerCaseMetaValue: noneMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.any,
+    metaValue: anyMetaValue,
+    lowerCaseMetaValue: anyMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.currency,
+    metaValue: currencyMetaValue,
+    lowerCaseMetaValue: currencyMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.float,
+    metaValue: floatMetaValue,
+    lowerCaseMetaValue: floatMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.hexNumber,
+    metaValue: hexNumberMetaValue,
+    lowerCaseMetaValue: hexNumberMetaValue.toLowerCase(),
+  },
+  {
+    styles: DotNetNumberStyles.integer,
+    metaValue: integerMetaValue,
+    lowerCaseMetaValue: integerMetaValue.toLowerCase(),
+  },
+];

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

@@ -0,0 +1,36 @@
+import { FtMetaDefaults } from '../../meta/ft-meta-defaults.js';
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class BooleanMetaSerialization {
+  static lowerCaseTrueText = FtMetaDefaults.BooleanField.TrueText.toLowerCase();
+  static lowerCaseFalseText = FtMetaDefaults.BooleanField.FalseText.toLowerCase();
+
+  static serialize(value: boolean, defaultValue: boolean): string | undefined {
+    if (value === defaultValue) {
+      return undefined; // Default value
+    } else {
+      return value ? FtMetaDefaults.BooleanField.TrueText : FtMetaDefaults.BooleanField.FalseText;
+    }
+  }
+
+  static deserialize(value: unknown, defaultValue: boolean, warnings: string[]): boolean {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`Boolean: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        const trimmedValue = value.trim().toLowerCase();
+        if (trimmedValue === BooleanMetaSerialization.lowerCaseTrueText) {
+          return true;
+        } else if (trimmedValue === BooleanMetaSerialization.lowerCaseFalseText) {
+          return false;
+        } else {
+          warnings.push(`Boolean: Invalid: ${value}`);
+          return defaultValue;
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,28 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class CharMetaSerialization {
+  static serialize(value: string, defaultValue: string): string | undefined {
+    if (value === defaultValue) {
+      return undefined; // Default value
+    } else {
+      return value;
+    }
+  }
+
+  static deserialize(value: unknown, defaultValue: string, warnings: string[]): string {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`Char: Type: ${typeof value}`);
+        return defaultValue;
+      } else {
+        if (value.length !== 1) {
+          warnings.push(`Char: Length: ${value}`);
+          return defaultValue;
+        } else {
+          return value;
+        }
+      }
+    }
+  }
+}