@pbkware/fielded-text-web 0.1.0

package/src/meta/fields/ft-decimal-meta-field.ts

@@ -0,0 +1,68 @@
+import { DotNetNumberStyles } from '@pbkware/dot-net-date-number-formatting';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
+import { FtMetaDefaults } from '../ft-meta-defaults.js';
+import { FtGenericMetaField } from './ft-generic-meta-field.js';
+import { FtMetaField } from './ft-meta-field.js';
+
+/**
+ * Meta field for decimal values.
+ * @public
+ */
+export class FtDecimalMetaField extends FtGenericMetaField<number> {
+  static readonly DATA_TYPE = FtDataType.Decimal;
+
+  static readonly DEFAULT_FORMAT = FtMetaDefaults.DecimalField.Format;
+  static readonly DEFAULT_STYLES = FtMetaDefaults.DecimalField.Styles;
+  static readonly DEFAULT_VALUE = FtMetaDefaults.DecimalField.Value;
+  static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE = FtMetaDefaults.DecimalField.SequenceRedirectType;
+
+  private _format: string = FtDecimalMetaField.DEFAULT_FORMAT;
+  private _styles: DotNetNumberStyles = FtDecimalMetaField.DEFAULT_STYLES;
+
+  constructor(headingCount = 0) {
+    super(FtDecimalMetaField.DATA_TYPE, headingCount, FtDecimalMetaField.DEFAULT_VALUE);
+  }
+
+  get format(): string {
+    return this._format;
+  }
+  set format(value: string) {
+    this._format = value;
+  }
+
+  get styles(): DotNetNumberStyles {
+    return this._styles;
+  }
+  set styles(value: DotNetNumberStyles) {
+    this._styles = value;
+  }
+
+  static isDecimalMetaField(field: FtMetaField): field is FtDecimalMetaField {
+    return field.dataType === FtDecimalMetaField.DATA_TYPE;
+  }
+
+  override loadDefaults(leaveNameAsIs = true): void {
+    super.loadDefaults(leaveNameAsIs);
+    this._format = FtDecimalMetaField.DEFAULT_FORMAT;
+    this._styles = FtDecimalMetaField.DEFAULT_STYLES;
+  }
+
+  createCopy(): FtMetaField {
+    const field = new FtDecimalMetaField(this.headingCount);
+    field.assignFrom(this);
+    return field;
+  }
+
+  protected getDefaultSequenceRedirectType(): FtSequenceRedirectType {
+    return FtDecimalMetaField.DEFAULT_SEQUENCE_REDIRECT_TYPE;
+  }
+
+  protected override assignFrom(source: FtMetaField): void {
+    super.assignFrom(source);
+    if (source instanceof FtDecimalMetaField) {
+      this._format = source._format;
+      this._styles = source._styles;
+    }
+  }
+}

package/src/meta/fields/ft-float-meta-field.ts

@@ -0,0 +1,68 @@
+import { DotNetNumberStyles } from '@pbkware/dot-net-date-number-formatting';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
+import { FtMetaDefaults } from '../ft-meta-defaults.js';
+import { FtGenericMetaField } from './ft-generic-meta-field.js';
+import { FtMetaField } from './ft-meta-field.js';
+
+/**
+ * Meta field for float (number) values.
+ * @public
+ */
+export class FtFloatMetaField extends FtGenericMetaField<number> {
+  static readonly DATA_TYPE = FtDataType.Float;
+
+  static readonly DEFAULT_FORMAT = FtMetaDefaults.FloatField.Format;
+  static readonly DEFAULT_STYLES = FtMetaDefaults.FloatField.Styles;
+  static readonly DEFAULT_VALUE = FtMetaDefaults.FloatField.Value;
+  static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE = FtMetaDefaults.FloatField.SequenceRedirectType;
+
+  private _format: string = FtFloatMetaField.DEFAULT_FORMAT;
+  private _styles: DotNetNumberStyles = FtFloatMetaField.DEFAULT_STYLES;
+
+  constructor(headingCount = 0) {
+    super(FtFloatMetaField.DATA_TYPE, headingCount, FtFloatMetaField.DEFAULT_VALUE);
+  }
+
+  get format(): string {
+    return this._format;
+  }
+  set format(value: string) {
+    this._format = value;
+  }
+
+  get styles(): DotNetNumberStyles {
+    return this._styles;
+  }
+  set styles(value: DotNetNumberStyles) {
+    this._styles = value;
+  }
+
+  static isFloatMetaField(field: FtMetaField): field is FtFloatMetaField {
+    return field.dataType === FtFloatMetaField.DATA_TYPE;
+  }
+
+  override loadDefaults(leaveNameAsIs = true): void {
+    super.loadDefaults(leaveNameAsIs);
+    this._format = FtFloatMetaField.DEFAULT_FORMAT;
+    this._styles = FtFloatMetaField.DEFAULT_STYLES;
+  }
+
+  createCopy(): FtMetaField {
+    const field = new FtFloatMetaField(this.headingCount);
+    field.assignFrom(this);
+    return field;
+  }
+
+  protected getDefaultSequenceRedirectType(): FtSequenceRedirectType {
+    return FtFloatMetaField.DEFAULT_SEQUENCE_REDIRECT_TYPE;
+  }
+
+  protected override assignFrom(source: FtMetaField): void {
+    super.assignFrom(source);
+    if (source instanceof FtFloatMetaField) {
+      this._format = source._format;
+      this._styles = source._styles;
+    }
+  }
+}

package/src/meta/fields/ft-generic-meta-field.ts

@@ -0,0 +1,38 @@
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtMetaField } from './ft-meta-field.js';
+
+/**
+ * Generic base class for typed meta fields.
+ * Provides value storage and management for fields with a specific value type.
+ * @public
+ */
+export abstract class FtGenericMetaField<T> extends FtMetaField {
+  private _defaultValue: T;
+  private _value: T;
+
+  protected constructor(dataType: FtDataType, headingCount: number, defaultValue: T) {
+    super(dataType, headingCount);
+    this._defaultValue = defaultValue;
+    this._value = defaultValue;
+  }
+
+  get value(): T {
+    return this._value;
+  }
+
+  set value(val: T) {
+    this._value = val;
+  }
+
+  override loadDefaults(leaveNameAsIs = true): void {
+    super.loadDefaults(leaveNameAsIs);
+    this._value = this._defaultValue;
+  }
+
+  protected override assignFrom(source: FtMetaField): void {
+    super.assignFrom(source);
+    if (source instanceof FtGenericMetaField) {
+      this._value = (source as FtGenericMetaField<T>)._value;
+    }
+  }
+}

package/src/meta/fields/ft-integer-meta-field.ts

@@ -0,0 +1,68 @@
+import { DotNetNumberStyles } from '@pbkware/dot-net-date-number-formatting';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtSequenceRedirectType } from '../../types/enums/ft-sequence-redirect-type.js';
+import { FtMetaDefaults } from '../ft-meta-defaults.js';
+import { FtGenericMetaField } from './ft-generic-meta-field.js';
+import { FtMetaField } from './ft-meta-field.js';
+
+/**
+ * Meta field for integer (bigint) values.
+ * @public
+ */
+export class FtIntegerMetaField extends FtGenericMetaField<bigint> {
+  static readonly DATA_TYPE = FtDataType.Integer;
+
+  static readonly DEFAULT_FORMAT = FtMetaDefaults.IntegerField.Format;
+  static readonly DEFAULT_STYLES = FtMetaDefaults.IntegerField.Styles;
+  static readonly DEFAULT_VALUE = FtMetaDefaults.IntegerField.Value;
+  static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE = FtMetaDefaults.IntegerField.SequenceRedirectType;
+
+  private _format: string = FtIntegerMetaField.DEFAULT_FORMAT;
+  private _styles: DotNetNumberStyles = FtIntegerMetaField.DEFAULT_STYLES;
+
+  constructor(headingCount = 0) {
+    super(FtIntegerMetaField.DATA_TYPE, headingCount, FtIntegerMetaField.DEFAULT_VALUE);
+  }
+
+  get format(): string {
+    return this._format;
+  }
+  set format(value: string) {
+    this._format = value;
+  }
+
+  get styles(): DotNetNumberStyles {
+    return this._styles;
+  }
+  set styles(value: DotNetNumberStyles) {
+    this._styles = value;
+  }
+
+  static isIntegerMetaField(field: FtMetaField): field is FtIntegerMetaField {
+    return field.dataType === FtIntegerMetaField.DATA_TYPE;
+  }
+
+  override loadDefaults(leaveNameAsIs = true): void {
+    super.loadDefaults(leaveNameAsIs);
+    this._format = FtIntegerMetaField.DEFAULT_FORMAT;
+    this._styles = FtIntegerMetaField.DEFAULT_STYLES;
+  }
+
+  createCopy(): FtMetaField {
+    const field = new FtIntegerMetaField(this.headingCount);
+    field.assignFrom(this);
+    return field;
+  }
+
+  protected getDefaultSequenceRedirectType(): FtSequenceRedirectType {
+    return FtIntegerMetaField.DEFAULT_SEQUENCE_REDIRECT_TYPE;
+  }
+
+  protected override assignFrom(source: FtMetaField): void {
+    super.assignFrom(source);
+    if (source instanceof FtIntegerMetaField) {
+      this._format = source._format;
+      this._styles = source._styles;
+    }
+  }
+}

package/src/meta/fields/ft-meta-field-list.ts

@@ -0,0 +1,208 @@
+import { FtFieldFactory } from '../../factory/ft-field-factory.js';
+import { FtDataType } from '../../types/enums/ft-data-type.js';
+import { FtHeadingConstraint } from '../../types/enums/ft-heading-constraint.js';
+import { FtPadAlignment } from '../../types/enums/ft-pad-alignment.js';
+import { FtPadCharType } from '../../types/enums/ft-pad-char-type.js';
+import { FtQuotedType } from '../../types/enums/ft-quoted-type.js';
+import { FtTruncateType } from '../../types/enums/ft-truncate-type.js';
+import { FtMetaDefaults } from '../ft-meta-defaults.js';
+import type { FtMetaField } from './ft-meta-field.js';
+
+/**
+ * @public
+ */
+export class FtMetaFieldList {
+  // Event hooks
+  /** @internal */
+  onBeforeRemove: ((fieldIdx: number) => void) | undefined = undefined;
+  /** @internal */
+  onBeforeClear: (() => void) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingConstraintRequired: (() => FtHeadingConstraint) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingQuotedTypeRequired: (() => FtQuotedType) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingAlwaysWriteOptionalQuoteRequired: (() => boolean) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingWritePrefixSpaceRequired: (() => boolean) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingPadAlignmentRequired: (() => FtPadAlignment) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingPadCharTypeRequired: (() => FtPadCharType) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingPadCharRequired: (() => string) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingTruncateTypeRequired: (() => FtTruncateType) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingTruncateCharRequired: (() => string) | undefined = undefined;
+  /** @internal */
+  onDefaultHeadingEndOfValueCharRequired: (() => string) | undefined = undefined;
+
+  /** @internal */
+  private fields: FtMetaField[] = [];
+  /** @internal */
+  private _headingCount: number = FtMetaDefaults.Root.HeadingLineCount;
+
+  get count(): number {
+    return this.fields.length;
+  }
+
+  get headingCount(): number {
+    return this._headingCount;
+  }
+
+  set headingCount(value: number) {
+    this._headingCount = value;
+    // Update all existing fields
+    for (const field of this.fields) {
+      field.setHeadingCount(value);
+    }
+  }
+
+  get(index: number): FtMetaField {
+    return this.fields[index];
+  }
+
+  indexOf(field: FtMetaField): number {
+    return this.fields.indexOf(field);
+  }
+
+  findById(id: number): FtMetaField | undefined {
+    return this.fields.find((f) => f.id === id);
+  }
+
+  find(name: string): FtMetaField | undefined {
+    return this.fields.find((f) => f.name === name);
+  }
+
+  new(dataType: FtDataType): FtMetaField {
+    const field = FtFieldFactory.createMetaField(dataType, this._headingCount);
+    this.add(field);
+    return field;
+  }
+
+  removeAt(index: number): void {
+    if (this.onBeforeRemove) {
+      this.onBeforeRemove(index);
+    }
+    this.unbindFieldEvents(this.fields[index]);
+    this.fields.splice(index, 1);
+  }
+
+  remove(field: FtMetaField): void {
+    const index = this.fields.indexOf(field);
+    if (index >= 0) {
+      this.removeAt(index);
+    }
+  }
+
+  clear(): void {
+    if (this.onBeforeClear) {
+      this.onBeforeClear();
+    }
+    for (const field of this.fields) {
+      this.unbindFieldEvents(field);
+    }
+    this.fields = [];
+  }
+
+  set(value: FtMetaField[]): void {
+    this.clear();
+    const count = value.length;
+    for (let i = 0; i < count; i++) {
+      this.add(value[i]);
+    }
+  }
+
+  assign(source: FtMetaFieldList): void {
+    this.clear();
+
+    for (let i = 0; i < source.count; i++) {
+      const sourceField = source.get(i);
+      const field = sourceField.createCopy();
+      this.add(field);
+    }
+  }
+
+  private add(field: FtMetaField): void {
+    this.fields.push(field);
+    field.setHeadingCount(this._headingCount);
+    this.bindFieldEvents(field);
+  }
+
+  private bindFieldEvents(field: FtMetaField): void {
+    field.onDefaultHeadingConstraintRequired = () => {
+      if (this.onDefaultHeadingConstraintRequired) {
+        return this.onDefaultHeadingConstraintRequired();
+      }
+      return FtMetaDefaults.Root.HeadingConstraint;
+    };
+    field.onDefaultHeadingQuotedTypeRequired = () => {
+      if (this.onDefaultHeadingQuotedTypeRequired) {
+        return this.onDefaultHeadingQuotedTypeRequired();
+      }
+      return FtMetaDefaults.Root.HeadingQuotedType;
+    };
+    field.onDefaultHeadingAlwaysWriteOptionalQuoteRequired = () => {
+      if (this.onDefaultHeadingAlwaysWriteOptionalQuoteRequired) {
+        return this.onDefaultHeadingAlwaysWriteOptionalQuoteRequired();
+      }
+      return FtMetaDefaults.Root.HeadingAlwaysWriteOptionalQuote;
+    };
+    field.onDefaultHeadingWritePrefixSpaceRequired = () => {
+      if (this.onDefaultHeadingWritePrefixSpaceRequired) {
+        return this.onDefaultHeadingWritePrefixSpaceRequired();
+      }
+      return FtMetaDefaults.Root.HeadingWritePrefixSpace;
+    };
+    field.onDefaultHeadingPadAlignmentRequired = () => {
+      if (this.onDefaultHeadingPadAlignmentRequired) {
+        return this.onDefaultHeadingPadAlignmentRequired();
+      }
+      return FtMetaDefaults.Root.HeadingPadAlignment;
+    };
+    field.onDefaultHeadingPadCharTypeRequired = () => {
+      if (this.onDefaultHeadingPadCharTypeRequired) {
+        return this.onDefaultHeadingPadCharTypeRequired();
+      }
+      return FtMetaDefaults.Root.HeadingPadCharType;
+    };
+    field.onDefaultHeadingPadCharRequired = () => {
+      if (this.onDefaultHeadingPadCharRequired) {
+        return this.onDefaultHeadingPadCharRequired();
+      }
+      return FtMetaDefaults.Root.HeadingPadChar;
+    };
+    field.onDefaultHeadingTruncateTypeRequired = () => {
+      if (this.onDefaultHeadingTruncateTypeRequired) {
+        return this.onDefaultHeadingTruncateTypeRequired();
+      }
+      return FtMetaDefaults.Root.HeadingTruncateType;
+    };
+    field.onDefaultHeadingTruncateCharRequired = () => {
+      if (this.onDefaultHeadingTruncateCharRequired) {
+        return this.onDefaultHeadingTruncateCharRequired();
+      }
+      return FtMetaDefaults.Root.HeadingTruncateChar;
+    };
+    field.onDefaultHeadingEndOfValueCharRequired = () => {
+      if (this.onDefaultHeadingEndOfValueCharRequired) {
+        return this.onDefaultHeadingEndOfValueCharRequired();
+      }
+      return FtMetaDefaults.Root.HeadingEndOfValueChar;
+    };
+  }
+
+  private unbindFieldEvents(field: FtMetaField): void {
+    field.onDefaultHeadingConstraintRequired = undefined;
+    field.onDefaultHeadingQuotedTypeRequired = undefined;
+    field.onDefaultHeadingAlwaysWriteOptionalQuoteRequired = undefined;
+    field.onDefaultHeadingWritePrefixSpaceRequired = undefined;
+    field.onDefaultHeadingPadAlignmentRequired = undefined;
+    field.onDefaultHeadingPadCharTypeRequired = undefined;
+    field.onDefaultHeadingPadCharRequired = undefined;
+    field.onDefaultHeadingTruncateTypeRequired = undefined;
+    field.onDefaultHeadingTruncateCharRequired = undefined;
+    field.onDefaultHeadingEndOfValueCharRequired = undefined;
+  }
+}