@pbkware/fielded-text-web 0.1.0

package/src/meta-serialization/types/enums/sequence-invokation-delay-meta-serialization.ts

@@ -0,0 +1,44 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtSequenceInvokationDelay } from '../../../types/enums/ft-sequence-invokation-delay.js';
+
+export namespace SequenceInvokationDelayMetaSerialization {
+  export const defaultValue = FtMetaDefaults.SequenceRedirect.InvokationDelay;
+
+  export function serialize(value: FtSequenceInvokationDelay): string | undefined {
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, warnings: string[]): FtSequenceInvokationDelay {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`SequenceInvokationDelay: 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(`SequenceInvokationDelay: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtSequenceInvokationDelay, string> = {
+  [FtSequenceInvokationDelay.AfterField]: 'AfterField',
+  [FtSequenceInvokationDelay.AfterSequence]: 'AfterSequence',
+};
+
+const deserializeMap: Record<string, FtSequenceInvokationDelay> = {
+  AfterField: FtSequenceInvokationDelay.AfterField,
+  AfterSequence: FtSequenceInvokationDelay.AfterSequence,
+};

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

@@ -0,0 +1,86 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtDataType } from '../../../types/enums/ft-data-type.js';
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import { FtUnreachableCaseError } from '../../../types/errors/ft-internal-error.js';
+
+export namespace SequenceRedirectTypeMetaSerialization {
+  export const stringDefaultValue = FtMetaDefaults.StringField.SequenceRedirectType;
+  export const booleanDefaultValue = FtMetaDefaults.BooleanField.SequenceRedirectType;
+  export const integerDefaultValue = FtMetaDefaults.IntegerField.SequenceRedirectType;
+  export const floatDefaultValue = FtMetaDefaults.FloatField.SequenceRedirectType;
+  export const decimalDefaultValue = FtMetaDefaults.DecimalField.SequenceRedirectType;
+  export const dateTimeDefaultValue = FtMetaDefaults.DateTimeField.SequenceRedirectType;
+
+  export function serialize(value: FtSequenceRedirectType, dataType: FtDataType): string | undefined {
+    const defaultValue = calculateDefaultValue(dataType);
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, dataType: FtDataType, warnings: string[]): FtSequenceRedirectType {
+    const defaultValue = calculateDefaultValue(dataType);
+    if (typeof value === 'undefined') {
+      return defaultValue; // Default value
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`SequenceRedirectType: 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(`SequenceRedirectType: Value: ${value}`);
+          return defaultValue; // Default value
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+
+  function calculateDefaultValue(dataType: FtDataType): FtSequenceRedirectType {
+    switch (dataType) {
+      case FtDataType.String:
+        return stringDefaultValue;
+      case FtDataType.Boolean:
+        return booleanDefaultValue;
+      case FtDataType.Integer:
+        return integerDefaultValue;
+      case FtDataType.Float:
+        return floatDefaultValue;
+      case FtDataType.Decimal:
+        return decimalDefaultValue;
+      case FtDataType.DateTime:
+        return dateTimeDefaultValue;
+      default:
+        throw new FtUnreachableCaseError('SRTMSCDV99312', dataType);
+    }
+  }
+}
+
+const serializeMap: Record<FtSequenceRedirectType, string> = {
+  [FtSequenceRedirectType.Null]: 'Null',
+  [FtSequenceRedirectType.ExactString]: 'ExactString',
+  [FtSequenceRedirectType.CaseInsensitiveString]: 'CaseInsensitiveString',
+  [FtSequenceRedirectType.Boolean]: 'Boolean',
+  [FtSequenceRedirectType.ExactInteger]: 'ExactInteger',
+  [FtSequenceRedirectType.ExactFloat]: 'ExactFloat',
+  [FtSequenceRedirectType.ExactDateTime]: 'ExactDateTime',
+  [FtSequenceRedirectType.Date]: 'Date',
+  [FtSequenceRedirectType.ExactDecimal]: 'ExactDecimal',
+};
+
+const deserializeMap: Record<string, FtSequenceRedirectType> = {
+  Null: FtSequenceRedirectType.Null,
+  ExactString: FtSequenceRedirectType.ExactString,
+  CaseInsensitiveString: FtSequenceRedirectType.CaseInsensitiveString,
+  Boolean: FtSequenceRedirectType.Boolean,
+  ExactInteger: FtSequenceRedirectType.ExactInteger,
+  ExactFloat: FtSequenceRedirectType.ExactFloat,
+  ExactDateTime: FtSequenceRedirectType.ExactDateTime,
+  Date: FtSequenceRedirectType.Date,
+  ExactDecimal: FtSequenceRedirectType.ExactDecimal,
+};

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

@@ -0,0 +1,44 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtSubstitutionType } from '../../../types/enums/ft-substitution-type.js';
+
+export namespace SubstitutionTypeMetaSerialization {
+  export const defaultValue = FtMetaDefaults.Substitution.Type;
+
+  export function serialize(value: FtSubstitutionType): string | undefined {
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      return serializeMap[value];
+    }
+  }
+
+  export function deserialize(value: unknown, warnings: string[]): FtSubstitutionType {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`SubstitutionType: 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(`SubstitutionType: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtSubstitutionType, string> = {
+  [FtSubstitutionType.String]: 'String',
+  [FtSubstitutionType.AutoEndOfLine]: 'AutoEndOfLine',
+};
+
+const deserializeMap: Record<string, FtSubstitutionType> = {
+  String: FtSubstitutionType.String,
+  AutoEndOfLine: FtSubstitutionType.AutoEndOfLine,
+};

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

@@ -0,0 +1,58 @@
+import { FtMetaDefaults } from '../../../meta/ft-meta-defaults.js';
+import { FtTruncateType } from '../../../types/enums/ft-truncate-type.js';
+
+export namespace TruncateTypeMetaSerialization {
+  export const headingDefaultValue = FtMetaDefaults.Root.HeadingTruncateType;
+  export const valueDefaultValue = FtMetaDefaults.Field.ValueTruncateType;
+
+  export function serialize(value: FtTruncateType, isHeading: boolean, overridingHeadingDefault: FtTruncateType | 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: FtTruncateType | undefined,
+    warnings: string[],
+  ): FtTruncateType {
+    const defaultValue = isHeading ? (overridingHeadingDefault ?? headingDefaultValue) : valueDefaultValue;
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`TruncateType: 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(`TruncateType: Value: ${value}`);
+          return defaultValue;
+        } else {
+          return result;
+        }
+      }
+    }
+  }
+}
+
+const serializeMap: Record<FtTruncateType, string> = {
+  [FtTruncateType.Left]: 'Left',
+  [FtTruncateType.Right]: 'Right',
+  [FtTruncateType.TruncateChar]: 'TruncateChar',
+  [FtTruncateType.NullChar]: 'NullChar',
+  [FtTruncateType.Exception]: 'Exception',
+};
+
+const deserializeMap: Record<string, FtTruncateType> = {
+  Left: FtTruncateType.Left,
+  Right: FtTruncateType.Right,
+  TruncateChar: FtTruncateType.TruncateChar,
+  NullChar: FtTruncateType.NullChar,
+  Exception: FtTruncateType.Exception,
+};

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

@@ -0,0 +1,96 @@
+import { isDigitCharCode } from '@pbkware/js-utils';
+import { FtAssertError } from '../../types/errors/ft-internal-error.js';
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class FloatMetaSerialization {
+  static serialize(value: number, defaultValue: number): string | undefined {
+    if (value === defaultValue) {
+      return undefined; // Default value
+    } else {
+      if (!Number.isFinite(value)) {
+        throw new FtAssertError('FMSS99312');
+      } else {
+        return value.toString(10);
+      }
+    }
+  }
+
+  static deserialize(value: unknown, defaultValue: number, warnings: string[]): number {
+    if (typeof value === 'undefined') {
+      return defaultValue; // Default value
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`Float: Type: ${typeof value}`);
+        return defaultValue; // Default value
+      } else {
+        const trimmedValue = value.trim();
+
+        if (!this.isStringValid(trimmedValue)) {
+          warnings.push(`Float: Invalid: ${value}`);
+          return defaultValue; // Default value
+        } else {
+          const result = parseFloat(trimmedValue);
+          if (isNaN(result)) {
+            warnings.push(`Float: NaN: ${value}`);
+            return defaultValue; // Default value
+          } else {
+            return result;
+          }
+        }
+      }
+    }
+  }
+
+  private static isStringValid(trimmedValue: string): boolean {
+    const length = trimmedValue.length;
+
+    let gotDecimal = false;
+    let gotDigit = false;
+    let gotE = false;
+    let previousWasE = false;
+
+    for (let i = 0; i < length; i++) {
+      const char = trimmedValue[i];
+
+      switch (char) {
+        case '+':
+        case '-': {
+          if (i !== 0 && !previousWasE) {
+            return false;
+          } else {
+            previousWasE = false;
+            break;
+          }
+        }
+        case '.': {
+          if (gotDecimal || gotE) {
+            return false;
+          } else {
+            gotDecimal = true;
+            break;
+          }
+        }
+        case 'e':
+        case 'E': {
+          if (!gotDigit || gotE) {
+            return false;
+          } else {
+            gotE = true;
+            previousWasE = true;
+            break;
+          }
+        }
+        default: {
+          if (!isDigitCharCode(char.charCodeAt(0))) {
+            return false;
+          } else {
+            gotDigit = true;
+            previousWasE = false;
+          }
+        }
+      }
+    }
+
+    return gotDigit;
+  }
+}

package/src/meta-serialization/types/integer-float-meta-serialization.ts

@@ -0,0 +1,46 @@
+import { parseIntStrict } from '@pbkware/js-utils';
+import { FtAssertError } from '../../types/errors/ft-internal-error.js';
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class IntegerFloatMetaSerialization {
+  static serialize(value: number, allowNegative: boolean, defaultValue?: number): string | undefined {
+    if (value === defaultValue) {
+      return undefined;
+    } else {
+      if (!Number.isSafeInteger(value)) {
+        throw new FtAssertError('IFMSS99312');
+      } else {
+        if (!allowNegative && value < 0) {
+          throw new FtAssertError('IFMSS99313');
+        } else {
+          return value.toString(10);
+        }
+      }
+    }
+  }
+
+  static deserialize(value: unknown, defaultValue: number, allowNegative: boolean, warnings: string[]): number {
+    if (typeof value === 'undefined') {
+      return defaultValue; // Default value
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`Integer Float: Type: ${typeof value}`);
+        return defaultValue; // Default value
+      } else {
+        const trimmedValue = value.trim();
+        const result = parseIntStrict(trimmedValue);
+        if (result === undefined) {
+          warnings.push(`Integer Float: Invalid: ${value}`);
+          return defaultValue; // Default value
+        } else {
+          if (!allowNegative && result < 0) {
+            warnings.push(`Integer Float: Negative value: ${result}`);
+            return defaultValue;
+          } else {
+            return result;
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,44 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class IntegerMetaSerialization {
+  static serialize(value: bigint, defaultValue: bigint): string | undefined {
+    if (value === defaultValue) {
+      return undefined; // Default value
+    } else {
+      return value.toString(10);
+    }
+  }
+
+  static deserialize(value: unknown, defaultValue: bigint, warnings: string[]): bigint {
+    if (typeof value === 'undefined') {
+      return defaultValue;
+    } else {
+      if (typeof value !== 'string') {
+        warnings.push(`Integer: Type: ${typeof value}`);
+        return defaultValue; // Default value
+      } else {
+        const trimmedValue = value.trim();
+
+        let result: bigint;
+        try {
+          result = BigInt(trimmedValue);
+        } catch (e) {
+          if (e instanceof SyntaxError) {
+            warnings.push(`Integer: Syntax: ${value}`);
+          } else {
+            if (e instanceof RangeError) {
+              warnings.push(`Integer: Range: ${value}`);
+            } else {
+              if (e instanceof TypeError) {
+                warnings.push(`Integer: TypeError: ${value}`);
+              } else {
+                throw e;
+              }
+            }
+          }
+          return defaultValue;
+        }
+        return result;
+      }
+    }
+  }
+}

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

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

package/src/meta-serialization/utils/implicit-explicit-index-sorter.ts

@@ -0,0 +1,61 @@
+export interface ImplicitExplicitIndexSortRec<T> {
+  target: T;
+  implicitIndex: number;
+  explicitIndex: number;
+}
+
+export namespace ImplicitExplicitIndexSortRec {
+  export const INDEX_NOT_SET = -1;
+
+  export function compare(left: ImplicitExplicitIndexSortRec<unknown>, right: ImplicitExplicitIndexSortRec<unknown>): number {
+    const leftHasExplicit = left.explicitIndex !== INDEX_NOT_SET;
+    const rightHasExplicit = right.explicitIndex !== INDEX_NOT_SET;
+
+    const leftIndex = leftHasExplicit ? left.explicitIndex : left.implicitIndex;
+    const rightIndex = rightHasExplicit ? right.explicitIndex : right.implicitIndex;
+
+    const result = leftIndex - rightIndex;
+    if (result === 0) {
+      // If indices are equal, explicit indices take precedence
+      if (leftHasExplicit && !rightHasExplicit) {
+        return -1; // left comes before right
+      } else {
+        if (!leftHasExplicit && rightHasExplicit) {
+          return 1; // left comes after right
+        }
+      }
+    }
+    return result;
+  }
+
+  export function checkSortedArray(arr: ImplicitExplicitIndexSortRec<unknown>[], targetType: string, warnings: string[]): void {
+    let negativeWarned = false;
+    let outOfBoundsWarned = false;
+    let duplicateWarned = false;
+
+    const count = arr.length;
+    for (let i = 1; i < arr.length; i++) {
+      const rec = arr[i];
+      if (rec.explicitIndex !== i) {
+        if (rec.explicitIndex < 0) {
+          if (!negativeWarned) {
+            warnings.push(`One or more negative explicit index: ${targetType}`);
+            negativeWarned = true;
+          }
+        } else {
+          if (rec.explicitIndex >= count) {
+            if (!outOfBoundsWarned) {
+              warnings.push(`One or more explicit index out of bounds: ${targetType}`);
+              outOfBoundsWarned = true;
+            }
+          } else {
+            if (!duplicateWarned) {
+              warnings.push(`One or more duplicate explicit index: ${targetType}`);
+              duplicateWarned = true;
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/meta-serialization/utils/meta-serialization-redirect-sequence-resolver.ts

@@ -0,0 +1,43 @@
+import { FtMetaSequenceRedirect } from '../../meta/sequences/redirects/ft-meta-sequence-redirect.js';
+import { MetaSerializationSequenceNameResolver } from './meta-serialization-sequence-name-resolver.js';
+
+/** @internal */
+export class MetaSerializationRedirectSequenceResolver {
+  private _recs = new Array<MetaSerializationRedirectSequenceResolver.Rec>();
+
+  constructor(private readonly _sequenceNameResolver: MetaSerializationSequenceNameResolver) {}
+
+  add(redirect: FtMetaSequenceRedirect, sequenceName: string | undefined): void {
+    this._recs.push({ redirect, sequenceName });
+  }
+
+  resolve(warnings: string[]): void {
+    const count = this._recs.length;
+
+    for (let i = 0; i < count; i++) {
+      const redirectNameRec = this._recs[i];
+
+      const sequenceName = redirectNameRec.sequenceName;
+      if (sequenceName === undefined) {
+        warnings.push(`Sequence redirect with undefined sequence name: ${JSON.stringify(redirectNameRec.redirect)}`);
+        redirectNameRec.redirect.sequence = this._sequenceNameResolver.redirectUndefinedSequence;
+      } else {
+        const targetSequence = this._sequenceNameResolver.findDefinedNameSequence(sequenceName);
+        if (targetSequence === undefined) {
+          warnings.push(`Sequence redirect with unresolved sequence name: ${sequenceName}`);
+          redirectNameRec.redirect.sequence = this._sequenceNameResolver.newRedirectUnresolvedSequence(sequenceName);
+        } else {
+          redirectNameRec.redirect.sequence = targetSequence;
+        }
+      }
+    }
+  }
+}
+
+/** @internal */
+export namespace MetaSerializationRedirectSequenceResolver {
+  export interface Rec {
+    redirect: FtMetaSequenceRedirect;
+    sequenceName: string | undefined;
+  }
+}

package/src/meta-serialization/utils/meta-serialization-sequence-name-resolver.ts

@@ -0,0 +1,85 @@
+import { FtMetaSequence } from '../../meta/sequences/core/ft-meta-sequence.js';
+
+/** @internal */
+export class MetaSerializationSequenceNameResolver {
+  private static _baseRedirectUndefinedSequenceName = '---REDIRECT-UNDEFINED';
+  private static _baseRedirectUnresolvedSequenceName = '---REDIRECT-UNRESOLVED-';
+
+  private _recs = new Array<MetaSerializationSequenceNameResolver.Rec>();
+
+  private _redirectUndefinedSequence: FtMetaSequence | undefined;
+
+  get redirectUndefinedSequence(): FtMetaSequence {
+    if (this._redirectUndefinedSequence !== undefined) {
+      return this._redirectUndefinedSequence;
+    } else {
+      const name = this.generateUniqueName(MetaSerializationSequenceNameResolver._baseRedirectUndefinedSequenceName);
+      const sequence = new FtMetaSequence();
+      sequence.name = name;
+      this._redirectUndefinedSequence = sequence;
+      this.add({ sequence, name });
+      return sequence;
+    }
+  }
+
+  add(rec: MetaSerializationSequenceNameResolver.Rec): void {
+    this._recs.push(rec);
+  }
+
+  resolve(warnings: string[]): FtMetaSequence[] {
+    const recs = this._recs;
+    const count = recs.length;
+    const sequences = new Array<FtMetaSequence>(count);
+
+    for (let i = 0; i < count; i++) {
+      const rec = recs[i];
+      sequences[i] = rec.sequence;
+      const sequenceName = rec.name;
+      if (sequenceName === undefined) {
+        warnings.push(`Sequence with undefined name: ${JSON.stringify(rec.sequence)}`);
+      } else {
+        const existingRec = this._recs.find((r) => r.name === sequenceName);
+        if (existingRec !== undefined) {
+          warnings.push(`Duplicate sequence name: ${sequenceName}`);
+        }
+        this._recs.push(rec);
+      }
+    }
+    return sequences;
+  }
+
+  newRedirectUnresolvedSequence(unresolvedName: string): FtMetaSequence {
+    const baseName = `${MetaSerializationSequenceNameResolver._baseRedirectUnresolvedSequenceName}${unresolvedName}`;
+    const name = this.generateUniqueName(baseName);
+    const sequence = new FtMetaSequence();
+    sequence.name = name;
+    this.add({ sequence, name });
+    return sequence;
+  }
+
+  findDefinedNameSequence(name: string): FtMetaSequence | undefined {
+    const rec = this._recs.find((aRec) => aRec.name === name);
+    return rec?.sequence;
+  }
+
+  private generateUniqueName(baseName: string): string {
+    let suffix = 1;
+    let name = baseName;
+    while (this.findDefinedNameSequence(name) !== undefined) {
+      suffix++;
+      name = `${baseName}-${suffix}`;
+    }
+    return name;
+  }
+}
+
+/** @internal */
+export namespace MetaSerializationSequenceNameResolver {
+  export interface Rec {
+    sequence: FtMetaSequence;
+    name: string | undefined;
+  }
+}
+
+/** @internal */
+export namespace SequenceNameRec {}