@pbkware/fielded-text-web 0.1.0

package/src/types/enums/ft-boolean-styles.ts

@@ -0,0 +1,17 @@
+/**
+ * Flags enum for boolean parsing styles
+ * @public
+ */
+export const FtBooleanStyles = {
+  IgnoreCase: 1 << 0,
+  MatchFirstCharOnly: 1 << 1,
+  IgnoreTrailingChars: 1 << 2,
+  FalseIfNotMatchTrue: 1 << 3,
+} as const;
+
+/**
+ * @public
+ */
+export type FtBooleanStyles = (typeof FtBooleanStyles)[keyof typeof FtBooleanStyles];
+
+export const noneBooleanStyles: FtBooleanStyles = 0;

package/src/types/enums/ft-data-type.ts

@@ -0,0 +1,21 @@
+/**
+ * @public
+ */
+export const FtDataType = {
+  String: 'String',
+  Boolean: 'Boolean',
+  Integer: 'Integer',
+  Float: 'Float',
+  Decimal: 'Decimal',
+  DateTime: 'DateTime',
+} as const;
+
+/**
+ * @public
+ */
+export type FtDataType = (typeof FtDataType)[keyof typeof FtDataType];
+
+/**
+ * @public
+ */
+export type FtNumberDataType = typeof FtDataType.Integer | typeof FtDataType.Float | typeof FtDataType.Decimal;

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

@@ -0,0 +1,14 @@
+/**
+ * @public
+ */
+export const FtEndOfLineAutoWriteType = {
+  CrLf: 'CrLf',
+  Cr: 'Cr',
+  Lf: 'Lf',
+  Local: 'Local',
+} as const;
+
+/**
+ * @public
+ */
+export type FtEndOfLineAutoWriteType = (typeof FtEndOfLineAutoWriteType)[keyof typeof FtEndOfLineAutoWriteType];

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

@@ -0,0 +1,13 @@
+/**
+ * @public
+ */
+export const FtEndOfLineType = {
+  Auto: 'Auto',
+  Char: 'Char',
+  CrLf: 'CrLf',
+} as const;
+
+/**
+ * @public
+ */
+export type FtEndOfLineType = (typeof FtEndOfLineType)[keyof typeof FtEndOfLineType];

package/src/types/enums/ft-heading-constraint.ts

@@ -0,0 +1,15 @@
+/**
+ * @public
+ */
+export const FtHeadingConstraint = {
+  None: 'None',
+  AllConstant: 'AllConstant',
+  MainConstant: 'MainConstant',
+  NameConstant: 'NameConstant',
+  NameIsMain: 'NameIsMain',
+} as const;
+
+/**
+ * @public
+ */
+export type FtHeadingConstraint = (typeof FtHeadingConstraint)[keyof typeof FtHeadingConstraint];

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

@@ -0,0 +1,13 @@
+/**
+ * @public
+ */
+export const FtLastLineEndedType = {
+  Never: 'Never',
+  Always: 'Always',
+  Optional: 'Optional',
+} as const;
+
+/**
+ * @public
+ */
+export type FtLastLineEndedType = (typeof FtLastLineEndedType)[keyof typeof FtLastLineEndedType];

package/src/types/enums/ft-line-type.ts

@@ -0,0 +1,17 @@
+/**
+ * @public
+ */
+export const FtLineType = {
+  Comment: 'Comment',
+  Signature: 'Signature',
+  Declaration2: 'Declaration2',
+  EmbeddedMeta: 'EmbeddedMeta',
+  Heading: 'Heading',
+  Blank: 'Blank',
+  Record: 'Record',
+} as const;
+
+/**
+ * @public
+ */
+export type FtLineType = (typeof FtLineType)[keyof typeof FtLineType];

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

@@ -0,0 +1,16 @@
+/**
+ * @public
+ */
+export const FtMetaElementType = {
+  FieldedText: 'FieldedText',
+  Substitution: 'Substitution',
+  Field: 'Field',
+  Sequence: 'Sequence',
+  SequenceItem: 'SequenceItem',
+  SequenceRedirect: 'SequenceRedirect',
+} as const;
+
+/**
+ * @public
+ */
+export type FtMetaElementType = (typeof FtMetaElementType)[keyof typeof FtMetaElementType];

package/src/types/enums/ft-meta-reference-type.ts

@@ -0,0 +1,14 @@
+/**
+ * @public
+ */
+export const FtMetaReferenceType = {
+  None: 'None',
+  Embedded: 'Embedded',
+  File: 'File',
+  Url: 'Url',
+} as const;
+
+/**
+ * @public
+ */
+export type FtMetaReferenceType = (typeof FtMetaReferenceType)[keyof typeof FtMetaReferenceType];

package/src/types/enums/ft-meta-serialization-format.ts

@@ -0,0 +1,19 @@
+/**
+ * Meta serialization format.
+ * @public
+ */
+export const FtMetaSerializationFormat = {
+  /**
+   * XML format (compatible with Standard 0.9).
+   */
+  XML: 'XML',
+  /**
+   * JSON format (Alternative for experimental use).
+   */
+  JSON: 'JSON',
+} as const;
+
+/**
+ * @public
+ */
+export type FtMetaSerializationFormat = (typeof FtMetaSerializationFormat)[keyof typeof FtMetaSerializationFormat];

package/src/types/enums/ft-pad-alignment.ts

@@ -0,0 +1,13 @@
+/**
+ * @public
+ */
+export const FtPadAlignment = {
+  Auto: 'Auto',
+  Left: 'Left',
+  Right: 'Right',
+} as const;
+
+/**
+ * @public
+ */
+export type FtPadAlignment = (typeof FtPadAlignment)[keyof typeof FtPadAlignment];

package/src/types/enums/ft-pad-char-type.ts

@@ -0,0 +1,13 @@
+/**
+ * @public
+ */
+export const FtPadCharType = {
+  Auto: 'Auto',
+  Specified: 'Specified',
+  EndOfValue: 'EndOfValue',
+} as const;
+
+/**
+ * @public
+ */
+export type FtPadCharType = (typeof FtPadCharType)[keyof typeof FtPadCharType];

package/src/types/enums/ft-quoted-type.ts

@@ -0,0 +1,13 @@
+/**
+ * @public
+ */
+export const FtQuotedType = {
+  Never: 'Never',
+  Always: 'Always',
+  Optional: 'Optional',
+} as const;
+
+/**
+ * @public
+ */
+export type FtQuotedType = (typeof FtQuotedType)[keyof typeof FtQuotedType];

package/src/types/enums/ft-read-record-result.ts

@@ -0,0 +1,13 @@
+/**
+ * @public
+ */
+export const FtReadRecordResult = {
+  SameTable: 'SameTable',
+  NewTable: 'NewTable',
+  NoMoreRecords: 'NoMoreRecords',
+} as const;
+
+/**
+ * @public
+ */
+export type FtReadRecordResult = (typeof FtReadRecordResult)[keyof typeof FtReadRecordResult];

package/src/types/enums/ft-sequence-invokation-delay.ts

@@ -0,0 +1,12 @@
+/**
+ * @public
+ */
+export const FtSequenceInvokationDelay = {
+  AfterField: 'AfterField',
+  AfterSequence: 'AfterSequence',
+} as const;
+
+/**
+ * @public
+ */
+export type FtSequenceInvokationDelay = (typeof FtSequenceInvokationDelay)[keyof typeof FtSequenceInvokationDelay];

package/src/types/enums/ft-sequence-redirect-type.ts

@@ -0,0 +1,19 @@
+/**
+ * @public
+ */
+export const FtSequenceRedirectType = {
+  Null: 'Null',
+  ExactString: 'ExactString',
+  CaseInsensitiveString: 'CaseInsensitiveString',
+  Boolean: 'Boolean',
+  ExactInteger: 'ExactInteger',
+  ExactFloat: 'ExactFloat',
+  ExactDateTime: 'ExactDateTime',
+  Date: 'Date',
+  ExactDecimal: 'ExactDecimal',
+} as const;
+
+/**
+ * @public
+ */
+export type FtSequenceRedirectType = (typeof FtSequenceRedirectType)[keyof typeof FtSequenceRedirectType];

package/src/types/enums/ft-substitution-type.ts

@@ -0,0 +1,16 @@
+/**
+ * Specifies substitution type
+ * @public
+ */
+export const FtSubstitutionType = {
+  /**
+   * Substitution Type where Substitution Pair (Character and Token) are replaced by a string
+   */
+  String: 'String',
+  AutoEndOfLine: 'AutoEndOfLine',
+} as const;
+
+/**
+ * @public
+ */
+export type FtSubstitutionType = (typeof FtSubstitutionType)[keyof typeof FtSubstitutionType];

package/src/types/enums/ft-truncate-type.ts

@@ -0,0 +1,15 @@
+/**
+ * @public
+ */
+export const FtTruncateType = {
+  Left: 'Left',
+  Right: 'Right',
+  TruncateChar: 'TruncateChar',
+  NullChar: 'NullChar',
+  Exception: 'Exception',
+} as const;
+
+/**
+ * @public
+ */
+export type FtTruncateType = (typeof FtTruncateType)[keyof typeof FtTruncateType];

package/src/types/errors/ft-internal-error.ts

@@ -0,0 +1,15 @@
+import { InternalError, UnreachableCaseInternalError } from '@pbkware/js-utils';
+
+/** @public */
+export class FtAssertError extends InternalError {
+  constructor(code: string, message?: string) {
+    super(code, message, 'Ft:Assert');
+  }
+}
+
+/** @public */
+export class FtUnreachableCaseError extends UnreachableCaseInternalError {
+  constructor(code: string, value: never) {
+    super(code, value, undefined, 'Ft:UnreachableCase');
+  }
+}

package/src/types/errors/ft-serialization-error.ts

@@ -0,0 +1,53 @@
+/**
+ * Enumeration of serialization error codes.
+ * @public
+ */
+export const FtSerializationError = {
+  Abort: 'Abort',
+  DeclarationParameterNameIsZeroLength: 'DeclarationParameterNameIsZeroLength',
+  DeclaredParameterNameContainsSeparator: 'DeclaredParameterNameContainsSeparator',
+  DeclarationParameterNameNotTerminated: 'DeclarationParameterNameNotTerminated',
+  DeclarationParameterMissingValue: 'DeclarationParameterMissingValue',
+  DeclarationParameterValueNotQuoted: 'DeclarationParameterValueNotQuoted',
+  DeclarationParameterValueNotTerminated: 'DeclarationParameterValueNotTerminated',
+  DeclarationParametersMissingVersion: 'DeclarationParametersMissingVersion',
+  DeclarationParameterVersionIsNotFirst: 'DeclarationParameterVersionIsNotFirst',
+  DeclarationParameterInvalidVersion: 'DeclarationParameterInvalidVersion',
+  EmbeddedMetaNotFound: 'EmbeddedMetaNotFound',
+  IncompleteEmbeddedMeta: 'IncompleteEmbeddedMeta',
+  HeadingLineNotEnoughFields: 'HeadingLineNotEnoughFields',
+  RecordNotEnoughFields: 'RecordNotEnoughFields',
+  HeadingLineTooManyFields: 'HeadingLineTooManyFields',
+  RecordTooManyFields: 'RecordTooManyFields',
+  HeadingQuotedFieldMissingEndQuoteChar: 'HeadingQuotedFieldMissingEndQuoteChar',
+  ValueQuotedFieldMissingEndQuoteChar: 'ValueQuotedFieldMissingEndQuoteChar',
+  HeadingNonWhiteSpaceCharBeforeQuotesOpened: 'HeadingNonWhiteSpaceCharBeforeQuotesOpened',
+  ValueNonWhiteSpaceCharBeforeQuotesOpened: 'ValueNonWhiteSpaceCharBeforeQuotesOpened',
+  HeadingNonWhiteSpaceCharAfterQuotesClosed: 'HeadingNonWhiteSpaceCharAfterQuotesClosed',
+  ValueNonWhiteSpaceCharAfterQuotesClosed: 'ValueNonWhiteSpaceCharAfterQuotesClosed',
+  HeadingWidthNotReached: 'HeadingWidthNotReached',
+  ValueWidthNotReached: 'ValueWidthNotReached',
+  HeadingWidthExceeded: 'HeadingWidthExceeded',
+  ValueWidthExceeded: 'ValueWidthExceeded',
+  FieldValueToText: 'FieldValueToText',
+  FieldTruncated: 'FieldTruncated',
+  FieldConstantValueMismatch: 'FieldConstantValueMismatch',
+  FieldConstNameHeadingMismatch: 'FieldConstNameHeadingMismatch',
+  FieldTextParse: 'FieldTextParse',
+  MoreThanOneRootSequence: 'MoreThanOneRootSequence',
+  HeaderAlreadyWritten: 'HeaderAlreadyWritten',
+  LastLineEndedError: 'LastLineEndedError',
+  IncompleteDeclaration: 'IncompleteDeclaration',
+  InsufficientHeadingLines: 'InsufficientHeadingLines',
+  InvalidMeta: 'InvalidMeta',
+  LoadMetaFromText: 'LoadMetaFromText',
+  MetaReferenceFileNoHandler: 'MetaReferenceFileNoHandler',
+  LoadMetaFromFile: 'LoadMetaFromFile',
+  MetaReferenceUrlNoHandler: 'MetaReferenceUrlNoHandler',
+  LoadMetaFromUrl: 'LoadMetaFromUrl',
+} as const;
+
+/**
+ * @public
+ */
+export type FtSerializationError = (typeof FtSerializationError)[keyof typeof FtSerializationError];

package/src/types/errors/ft-serialization-exception.ts

@@ -0,0 +1,86 @@
+import { FtField } from '../../fields/instances/ft-field.js';
+import { FtSerializationError } from './ft-serialization-error.js';
+
+/**
+ * Exception thrown during fielded text serialization/deserialization.
+ * @public
+ */
+export class FtSerializationException extends Error {
+  private readonly _error: FtSerializationError;
+  private readonly _fieldName: string | undefined;
+  private readonly _fieldIndex: number;
+  private readonly _sequenceName: string | undefined;
+  private readonly _sequenceItemIndex: number;
+
+  constructor(error: FtSerializationError, fieldOrMessage: FtField | string | undefined, messageOrInner?: string | Error, innerException?: Error) {
+    let message: string;
+    let field: FtField | undefined = undefined;
+    let inner: Error | undefined = undefined;
+
+    // Overload resolution
+    if (typeof fieldOrMessage === 'string') {
+      // (error, message) or (error, message, innerException)
+      message = fieldOrMessage;
+      if (messageOrInner instanceof Error) {
+        inner = messageOrInner;
+      }
+    } else {
+      // (error, field, message) or (error, field, innerException) or (error, field, message, innerException)
+      field = fieldOrMessage;
+      if (typeof messageOrInner === 'string') {
+        message = messageOrInner;
+        inner = innerException;
+      } else if (messageOrInner instanceof Error) {
+        message = messageOrInner.message;
+        inner = messageOrInner;
+      } else {
+        message = '';
+      }
+    }
+
+    const errorName = FtSerializationError[error];
+    const fullMessage = errorName + (message ? ': ' + message : '');
+    super(fullMessage);
+
+    this.name = 'FtSerializationException';
+    this._error = error;
+
+    if (field === undefined) {
+      this._fieldName = undefined;
+      this._fieldIndex = -1;
+      this._sequenceName = undefined;
+      this._sequenceItemIndex = -1;
+    } else {
+      this._fieldName = field.name;
+      this._fieldIndex = field.index;
+      const sequence = field.sequence;
+      this._sequenceName = sequence.name;
+      const sequenceItem = field.sequenceItem;
+      this._sequenceItemIndex = sequenceItem.index;
+    }
+
+    if (inner) {
+      this.cause = inner;
+    }
+  }
+
+  get error(): FtSerializationError {
+    return this._error;
+  }
+
+  get fieldName(): string | undefined {
+    return this._fieldName;
+  }
+
+  get fieldIndex(): number {
+    return this._fieldIndex;
+  }
+
+  get sequenceName(): string | undefined {
+    return this._sequenceName;
+  }
+
+  get sequenceItemIndex(): number {
+    return this._sequenceItemIndex;
+  }
+}

package/src/types/events/ft-field-heading-ready-event-args.ts

@@ -0,0 +1,9 @@
+import { FtField } from '../../fields/instances/ft-field.js';
+
+/**
+ * @public
+ */
+export interface FtFieldHeadingReadyEventArgs {
+  field: FtField;
+  lineIndex: number;
+}

package/src/types/events/ft-field-value-ready-event-args.ts

@@ -0,0 +1,9 @@
+import { FtField } from '../../fields/instances/ft-field.js';
+
+/**
+ * @public
+ */
+export interface FtFieldValueReadyEventArgs {
+  field: FtField;
+  recordIndex: number;
+}

package/src/types/events/ft-heading-line-finished-event-args.ts

@@ -0,0 +1,6 @@
+/**
+ * @public
+ */
+export interface FtHeadingLineFinishedEventArgs {
+  lineIndex: number;
+}

package/src/types/events/ft-heading-line-started-event-args.ts

@@ -0,0 +1,6 @@
+/**
+ * @public
+ */
+export interface FtHeadingLineStartedEventArgs {
+  lineIndex: number;
+}

package/src/types/events/ft-record-finished-event-args.ts

@@ -0,0 +1,6 @@
+/**
+ * @public
+ */
+export interface FtRecordFinishedEventArgs {
+  recordIndex: number;
+}

package/src/types/events/ft-record-started-event-args.ts

@@ -0,0 +1,6 @@
+/**
+ * @public
+ */
+export interface FtRecordStartedEventArgs {
+  recordIndex: number;
+}

package/src/types/events/ft-sequence-redirected-event-args.ts

@@ -0,0 +1,9 @@
+import { FtField } from '../../fields/instances/ft-field.js';
+
+/**
+ * @public
+ */
+export interface FtSequenceRedirectedEventArgs {
+  redirectingField: FtField;
+  fieldsAffectedFromIndex: number;
+}