@pbkware/fielded-text-web 0.1.0

package/src/factory/ft-sequence-redirect-factory.ts

@@ -0,0 +1,197 @@
+import { Err, Ok, Result } from '@pbkware/js-utils';
+import { FtBooleanSequenceRedirect } from '../sequences/redirects/ft-boolean-sequence-redirect.js';
+import { FtCaseInsensitiveStringSequenceRedirect } from '../sequences/redirects/ft-case-insensitive-string-sequence-redirect.js';
+import { FtDateSequenceRedirect } from '../sequences/redirects/ft-date-sequence-redirect.js';
+import { FtExactDateTimeSequenceRedirect } from '../sequences/redirects/ft-exact-date-time-sequence-redirect.js';
+import { FtExactDecimalSequenceRedirect } from '../sequences/redirects/ft-exact-decimal-sequence-redirect.js';
+import { FtExactFloatSequenceRedirect } from '../sequences/redirects/ft-exact-float-sequence-redirect.js';
+import { FtExactIntegerSequenceRedirect } from '../sequences/redirects/ft-exact-integer-sequence-redirect.js';
+import { FtExactStringSequenceRedirect } from '../sequences/redirects/ft-exact-string-sequence-redirect.js';
+import { FtNullSequenceRedirect } from '../sequences/redirects/ft-null-sequence-redirect.js';
+import { FtSequenceRedirect } from '../sequences/redirects/ft-sequence-redirect.js';
+import { FtSequenceRedirectType } from '../types/enums/ft-sequence-redirect-type.js';
+import { FtSequenceRedirectConstructor } from './ft-sequence-redirect-constructor.js';
+
+// Concrete constructor implementations
+class NullSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtNullSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtNullSequenceRedirect.TYPE;
+  }
+}
+
+class BooleanSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtBooleanSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtBooleanSequenceRedirect.TYPE;
+  }
+}
+
+class ExactStringSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtExactStringSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtExactStringSequenceRedirect.TYPE;
+  }
+}
+
+class CaseInsensitiveStringSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtCaseInsensitiveStringSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtCaseInsensitiveStringSequenceRedirect.TYPE;
+  }
+}
+
+class ExactIntegerSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtExactIntegerSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtExactIntegerSequenceRedirect.TYPE;
+  }
+}
+
+class ExactFloatSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtExactFloatSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtExactFloatSequenceRedirect.TYPE;
+  }
+}
+
+class ExactDecimalSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtExactDecimalSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtExactDecimalSequenceRedirect.TYPE;
+  }
+}
+
+class ExactDateTimeSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtExactDateTimeSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtExactDateTimeSequenceRedirect.TYPE;
+  }
+}
+
+class DateSequenceRedirectConstructor extends FtSequenceRedirectConstructor {
+  createSequenceRedirect(index: number): FtSequenceRedirect {
+    return new FtDateSequenceRedirect(index);
+  }
+  protected getSequenceRedirectType(): FtSequenceRedirectType {
+    return FtDateSequenceRedirect.TYPE;
+  }
+}
+
+/**
+ * Factory for creating sequence redirects.
+ * Manages a registry of redirect types and their constructors.
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class FtSequenceRedirectFactory {
+  private static constructorList: FtSequenceRedirectConstructor[] = [];
+
+  // Static initializer - register standard constructors
+  private static initialized = (() => {
+    FtSequenceRedirectFactory.constructorList = [];
+    FtSequenceRedirectFactory.constructorList.push(new NullSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new BooleanSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new CaseInsensitiveStringSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new DateSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new ExactDateTimeSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new ExactDecimalSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new ExactFloatSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new ExactIntegerSequenceRedirectConstructor());
+    FtSequenceRedirectFactory.constructorList.push(new ExactStringSequenceRedirectConstructor());
+    return true;
+  })();
+
+  static registerConstructor(constructor: FtSequenceRedirectConstructor): void {
+    if (FtSequenceRedirectFactory.tryFindConstructorByType(constructor.sequenceRedirectType)) {
+      throw new Error(`SequenceRedirect type ${constructor.sequenceRedirectType} is already registered`);
+    }
+    if (FtSequenceRedirectFactory.tryFindConstructorByName(constructor.sequenceRedirectTypeName)) {
+      throw new Error(`SequenceRedirect type name "${constructor.sequenceRedirectTypeName}" is already registered`);
+    }
+    FtSequenceRedirectFactory.constructorList.push(constructor);
+  }
+
+  static getRegisteredConstructors(): FtSequenceRedirectConstructor[] {
+    return [...FtSequenceRedirectFactory.constructorList];
+  }
+
+  static unregisterAllConstructors(): void {
+    FtSequenceRedirectFactory.constructorList = [];
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  static unregisterConstructor(constructorOrType: FtSequenceRedirectConstructor | FtSequenceRedirectType | string): void {
+    if (typeof constructorOrType === 'number') {
+      const idx = FtSequenceRedirectFactory.constructorList.findIndex((c) => c.sequenceRedirectType === constructorOrType);
+      if (idx >= 0) {
+        FtSequenceRedirectFactory.constructorList.splice(idx, 1);
+      }
+    } else if (typeof constructorOrType === 'string') {
+      const lowerName = constructorOrType.toLowerCase();
+      const idx = FtSequenceRedirectFactory.constructorList.findIndex((c) => c.sequenceRedirectTypeName.toLowerCase() === lowerName);
+      if (idx >= 0) {
+        FtSequenceRedirectFactory.constructorList.splice(idx, 1);
+      }
+    } else {
+      const idx = FtSequenceRedirectFactory.constructorList.indexOf(constructorOrType);
+      if (idx >= 0) {
+        FtSequenceRedirectFactory.constructorList.splice(idx, 1);
+      }
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  static createSequenceRedirect(index: number, typeOrName: FtSequenceRedirectType | string): FtSequenceRedirect {
+    const constructor =
+      typeof typeOrName === 'number'
+        ? FtSequenceRedirectFactory.tryFindConstructorByType(typeOrName)
+        : FtSequenceRedirectFactory.tryFindConstructorByName(typeOrName);
+
+    if (!constructor) {
+      throw new Error(`No constructor found for sequence redirect type: ${typeOrName}`);
+    }
+    return constructor.createSequenceRedirect(index);
+  }
+
+  static getName(type: FtSequenceRedirectType): string {
+    const constructor = FtSequenceRedirectFactory.tryFindConstructorByType(type);
+    if (!constructor) {
+      throw new Error(`No constructor found for type: ${type}`);
+    }
+    return constructor.sequenceRedirectTypeName;
+  }
+
+  static tryGetType(typeName: string): Result<FtSequenceRedirectType, boolean> {
+    const constructor = FtSequenceRedirectFactory.tryFindConstructorByName(typeName);
+    if (constructor) {
+      return new Ok(constructor.sequenceRedirectType);
+    }
+    return new Err(false);
+  }
+
+  private static tryFindConstructorByType(type: FtSequenceRedirectType): FtSequenceRedirectConstructor | undefined {
+    return FtSequenceRedirectFactory.constructorList.find((c) => c.sequenceRedirectType === type);
+  }
+
+  private static tryFindConstructorByName(typeName: string): FtSequenceRedirectConstructor | undefined {
+    const lowerName = typeName.toLowerCase();
+    return FtSequenceRedirectFactory.constructorList.find((c) => c.sequenceRedirectTypeName.toLowerCase() === lowerName);
+  }
+}

package/src/factory/ft-substitution-constructor.ts

@@ -0,0 +1,24 @@
+import { FtMetaSubstitution } from '../meta/substitutions/ft-meta-substitution-list.js';
+import { FtSubstitution } from '../substitutions/ft-substitution-list.js';
+
+/**
+ * Base constructor class for creating substitution instances.
+ * Can be extended to provide custom substitution creation logic.
+ * @public
+ */
+export class FtSubstitutionConstructor {
+  /**
+   * Create a new FtSubstitution instance for runtime use.
+   * @param index - The index of the substitution in the list
+   */
+  createSubstitution(index: number): FtSubstitution {
+    return new FtSubstitution(index);
+  }
+
+  /**
+   * Create a new FtMetaSubstitution instance for metadata definition.
+   */
+  createMetaSubstitution(): FtMetaSubstitution {
+    return new FtMetaSubstitution();
+  }
+}

package/src/factory/ft-substitution-factory.ts

@@ -0,0 +1,43 @@
+import { FtMetaSubstitution } from '../meta/substitutions/ft-meta-substitution-list.js';
+import { FtSubstitution } from '../substitutions/ft-substitution-list.js';
+import { FtSubstitutionConstructor } from './ft-substitution-constructor.js';
+
+/**
+ * Factory for creating substitution instances.
+ * Provides a global constructor that can be replaced to customize substitution creation.
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class FtSubstitutionFactory {
+  private static _constructor: FtSubstitutionConstructor = new FtSubstitutionConstructor();
+
+  /**
+   * Get the current substitution constructor.
+   */
+  static getConstructor(): FtSubstitutionConstructor {
+    return FtSubstitutionFactory._constructor;
+  }
+
+  /**
+   * Set a custom substitution constructor.
+   * Use this to provide custom initialization logic for all substitution instances.
+   */
+  static setConstructor(value: FtSubstitutionConstructor): void {
+    FtSubstitutionFactory._constructor = value;
+  }
+
+  /**
+   * Create a new FtSubstitution instance using the current constructor.
+   * @param index - The index of the substitution in the list
+   */
+  static createSubstitution(index: number): FtSubstitution {
+    return FtSubstitutionFactory._constructor.createSubstitution(index);
+  }
+
+  /**
+   * Create a new FtMetaSubstitution instance using the current constructor.
+   */
+  static createMetaSubstitution(): FtMetaSubstitution {
+    return FtSubstitutionFactory._constructor.createMetaSubstitution();
+  }
+}

package/src/fields/definitions/ft-boolean-field-definition.ts

@@ -0,0 +1,49 @@
+import { DotNetLocaleSettings } from '@pbkware/dot-net-date-number-formatting';
+import { FtBooleanMetaField } from '../../meta/fields/ft-boolean-meta-field.js';
+import { FtBooleanFieldFormatter } from '../../serialization/formatting/ft-boolean-field-formatter.js';
+import { FtBooleanStyles } from '../../types/enums/ft-boolean-styles.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtGenericFieldDefinition } from './ft-generic-field-definition.js';
+
+/**
+ * Field definition for boolean fields.
+ * @public
+ */
+export class FtBooleanFieldDefinition extends FtGenericFieldDefinition<boolean> {
+  static readonly AUTO_LEFT_PAD = false;
+
+  declare protected formatter: FtBooleanFieldFormatter;
+
+  constructor(index: number) {
+    const formatter = new FtBooleanFieldFormatter();
+    super(FtDataType.Boolean, 'boolean', formatter, FtBooleanFieldDefinition.AUTO_LEFT_PAD, index);
+  }
+
+  get falseText(): string {
+    return this.formatter.falseText;
+  }
+
+  get trueText(): string {
+    return this.formatter.trueText;
+  }
+
+  get styles(): FtBooleanStyles {
+    return this.formatter.styles;
+  }
+
+  override loadMeta(metaField: FtBooleanMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void {
+    super.loadMeta(metaField, myCulture, myMainHeadingIndex);
+
+    this.formatter.falseText = metaField.falseText;
+    this.formatter.trueText = metaField.trueText;
+    this.formatter.styles = metaField.styles;
+  }
+
+  getValueText(value: boolean): string {
+    return this.formatter.toText(value);
+  }
+
+  parseValueText(text: string): boolean {
+    return this.formatter.parse(text);
+  }
+}

package/src/fields/definitions/ft-date-time-field-definition.ts

@@ -0,0 +1,52 @@
+import { DotNetDateTimeStyles, DotNetLocaleSettings } from '@pbkware/dot-net-date-number-formatting';
+import { FtDateTimeMetaField } from '../../meta/fields/ft-date-time-meta-field.js';
+import { FtMetaField } from '../../meta/fields/ft-meta-field.js';
+import { FtDateTimeFieldFormatter } from '../../serialization/formatting/ft-date-time-field-formatter.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtGenericFieldDefinition } from './ft-generic-field-definition.js';
+
+/**
+ * Field definition for DateTime fields.
+ * @public
+ */
+export class FtDateTimeFieldDefinition extends FtGenericFieldDefinition<Date> {
+  static readonly AUTO_LEFT_PAD = true;
+
+  declare protected formatter: FtDateTimeFieldFormatter;
+
+  private _constantValue: Date = new Date(FtDateTimeMetaField.DEFAULT_VALUE);
+
+  constructor(index: number) {
+    const formatter = new FtDateTimeFieldFormatter();
+    super(FtDataType.DateTime, 'Date', formatter, FtDateTimeFieldDefinition.AUTO_LEFT_PAD, index);
+  }
+
+  get format(): string {
+    return this.formatter.format;
+  }
+
+  get styles(): DotNetDateTimeStyles {
+    return this.formatter.styles;
+  }
+
+  get constantValue(): Date {
+    return this._constantValue;
+  }
+
+  override loadMeta(metaField: FtMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void {
+    super.loadMeta(metaField, myCulture, myMainHeadingIndex);
+
+    const dateTimeMetaField = metaField as FtDateTimeMetaField;
+    this.formatter.format = dateTimeMetaField.format;
+    this.formatter.styles = dateTimeMetaField.styles;
+    this._constantValue = dateTimeMetaField.value;
+  }
+
+  getValueText(value: Date): string {
+    return this.formatter.toText(value);
+  }
+
+  parseValueText(text: string): Date {
+    return this.formatter.parse(text);
+  }
+}

package/src/fields/definitions/ft-decimal-field-definition.ts

@@ -0,0 +1,43 @@
+import { DotNetLocaleSettings, DotNetNumberStyles } from '@pbkware/dot-net-date-number-formatting';
+import { FtDecimalMetaField } from '../../meta/fields/ft-decimal-meta-field.js';
+import { FtDecimalFieldFormatter } from '../../serialization/formatting/ft-decimal-field-formatter.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtGenericFieldDefinition } from './ft-generic-field-definition.js';
+
+/**
+ * Field definition for decimal fields.
+ * @public
+ */
+export class FtDecimalFieldDefinition extends FtGenericFieldDefinition<number> {
+  static readonly AUTO_LEFT_PAD = true;
+
+  declare protected formatter: FtDecimalFieldFormatter;
+
+  constructor(index: number) {
+    const formatter = new FtDecimalFieldFormatter();
+    super(FtDataType.Decimal, 'number', formatter, FtDecimalFieldDefinition.AUTO_LEFT_PAD, index);
+  }
+
+  get format(): string {
+    return this.formatter.format;
+  }
+
+  get styles(): DotNetNumberStyles {
+    return this.formatter.styles;
+  }
+
+  override loadMeta(metaField: FtDecimalMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void {
+    super.loadMeta(metaField, myCulture, myMainHeadingIndex);
+
+    this.formatter.format = metaField.format;
+    this.formatter.styles = metaField.styles;
+  }
+
+  getValueText(value: number): string {
+    return this.formatter.toText(value);
+  }
+
+  parseValueText(text: string): number {
+    return this.formatter.parse(text);
+  }
+}

package/src/fields/definitions/ft-field-definition-list.ts

@@ -0,0 +1,33 @@
+import { FtFieldFactory } from '../../factory/ft-field-factory.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtFieldDefinition } from './ft-field-definition.js';
+
+/**
+ * List of field definitions.
+ * @public
+ */
+export class FtFieldDefinitionList {
+  private _items: FtFieldDefinition[] = [];
+
+  get count(): number {
+    return this._items.length;
+  }
+
+  get(index: number): FtFieldDefinition {
+    return this._items[index];
+  }
+
+  add(definition: FtFieldDefinition): void {
+    this._items.push(definition);
+  }
+
+  new(dataType: FtDataType): FtFieldDefinition {
+    const definition = FtFieldFactory.createFieldDefinition(dataType, this.count);
+    this._items.push(definition);
+    return definition;
+  }
+
+  clear(): void {
+    this._items = [];
+  }
+}