@pbkware/dot-net-date-number-formatting 0.2.0 → 0.3.0

package/dist/types/public-api.d.ts

@@ -33,16 +33,29 @@ import { Result } from '@pbkware/js-utils';
  */
 export declare class DotNetDateTimeFormatter {
     /**
-     * Set of date/time style flags that are not currently supported by this implementation.
+     * Array of date/time style flags that are not currently supported by this implementation.
      * Operations using these styles will fail.
      */
-    static readonly unsupportedStyles: Set<DotNetDateTimeStyleId>;
+    static readonly unsupportedStyles: (16 | 32 | 64 | 128)[];
     private format;
     /**
-     * The set of {@link DotNetDateTimeStyleId} flags that control date/time parsing behavior.
-     * Currently only used for future parsing functionality.
+     * The {@link (DotNetDateTimeStyles:type)} flags that control date/time parsing behavior.
+     *
+     * Use predefined combinations from {@link (DotNetDateTimeStyles:variable)} or combine
+     * {@link (DotNetDateTimeStyleFlags:variable)} using bitwise OR.
+     *
+     * @example
+     * ```typescript
+     * // Use predefined combination
+     * formatter.styles = DotNetDateTimeStyles.allowWhiteSpaces;
+     *
+     * // Combine individual flags
+     * formatter.styles =
+     *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+     *   DotNetDateTimeStyleFlags.allowTrailingWhite;
+     * ```
      */
-    styles: DotNetDateTimeStyleSet;
+    styles: DotNetDateTimeStyles;
     /**
      * The locale settings that determine date/time separators and formatting conventions.
      */
@@ -103,50 +116,105 @@ export declare class DotNetDateTimeFormatter {
 /**
  * Individual style flags that control date/time parsing behavior.
  *
- * These flags can be combined to create custom parsing rules.
+ * These flags can be combined using bitwise OR to create custom parsing rules.
  *
  * @example
  * ```typescript
- * // Combine individual flags
- * formatter.styles = new Set([
- *   DotNetDateTimeStyleId.AllowLeadingWhite,
- *   DotNetDateTimeStyleId.AllowTrailingWhite
- * ]);
+ * const formatter = new DotNetDateTimeFormatter();
+ *
+ * // Combine multiple flags using bitwise OR
+ * formatter.styles =
+ *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+ *   DotNetDateTimeStyleFlags.allowTrailingWhite;
  * ```
  *
  * @public
  * @category DateTime Styles
  */
-export declare enum DotNetDateTimeStyleId {
+export declare const DotNetDateTimeStyleFlags: {
     /** Allow leading whitespace characters. */
-    AllowLeadingWhite = "AllowLeadingWhite",
+    readonly allowLeadingWhite: 1;
     /** Allow trailing whitespace characters. */
-    AllowTrailingWhite = "AllowTrailingWhite",
+    readonly allowTrailingWhite: 2;
     /** Allow whitespace within the date/time string. */
-    AllowInnerWhite = "AllowInnerWhite",
+    readonly allowInnerWhite: 4;
     /** Do not use current date for missing date components. */
-    NoCurrentDateDefault = "NoCurrentDateDefault",
+    readonly noCurrentDateDefault: 8;
     /** Adjust date/time to UTC (not implemented). */
-    AdjustToUniversal = "AdjustToUniversal",
+    readonly adjustToUniversal: 16;
     /** Assume local time zone if not specified (not implemented). */
-    AssumeLocal = "AssumeLocal",
+    readonly assumeLocal: 32;
     /** Assume UTC time zone if not specified (not implemented). */
-    AssumeUniversal = "AssumeUniversal",
+    readonly assumeUniversal: 64;
     /** Preserve DateTimeKind when parsing (not implemented). */
-    RoundTripKind = "RoundTripKind"
-}
-
-/* Excluded from this release type: DotNetDateTimeStyles */
+    readonly roundTripKind: 128;
+};
 
 /**
- * A set of {@link DotNetDateTimeStyleId} flags.
+ * The type representing possible values of {@link (DotNetDateTimeStyleFlags:variable)}.
+ *
+ * Flags can be combined using bitwise OR to create custom parsing behaviors.
  *
  * @public
  * @category DateTime Styles
  */
-export declare type DotNetDateTimeStyleSet = Set<DotNetDateTimeStyleId>;
+export declare type DotNetDateTimeStyleFlags = (typeof DotNetDateTimeStyleFlags)[keyof typeof DotNetDateTimeStyleFlags];
 
-/* Excluded from this release type: DotNetDateTimeStylesInfo */
+/**
+ * Predefined date/time style combinations for common parsing scenarios.
+ *
+ * Contains individual {@link (DotNetDateTimeStyleFlags:variable)} as well as common combinations.
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetDateTimeFormatter();
+ *
+ * // Use a predefined combination
+ * formatter.styles = DotNetDateTimeStyles.allowWhiteSpaces;
+ *
+ * // Or use individual flags
+ * formatter.styles = DotNetDateTimeStyles.allowLeadingWhite;
+ *
+ * // Or combine flags manually
+ * formatter.styles =
+ *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+ *   DotNetDateTimeStyleFlags.noCurrentDateDefault;
+ * ```
+ *
+ * @category DateTime Styles
+ * @public
+ */
+export declare const DotNetDateTimeStyles: {
+    /** No styles - strict parsing. */
+    readonly none: 0;
+    readonly allowLeadingWhite: 1;
+    readonly allowTrailingWhite: 2;
+    readonly allowInnerWhite: 4;
+    /**
+     * Allow whitespace in date/time strings.
+     * Includes: allowLeadingWhite, allowTrailingWhite, allowInnerWhite.
+     */
+    readonly allowWhiteSpaces: number;
+    readonly noCurrentDateDefault: 8;
+    /** Adjust date/time to UTC (not implemented). */
+    readonly adjustToUniversal: 16;
+    /** Assume local time zone if not specified (not implemented). */
+    readonly assumeLocal: 32;
+    /** Assume UTC time zone if not specified (not implemented). */
+    readonly assumeUniversal: 64;
+    /** Preserve DateTimeKind when parsing (not implemented). */
+    readonly roundTripKind: 128;
+};
+
+/**
+ * The type representing possible values of {@link (DotNetDateTimeStyles:variable)}.
+ *
+ * This includes individual {@link (DotNetDateTimeStyleFlags:variable)} and predefined combinations.
+ *
+ * @public
+ * @category DateTime Styles
+ */
+export declare type DotNetDateTimeStyles = (typeof DotNetDateTimeStyles)[keyof typeof DotNetDateTimeStyles];
 
 /**
  * Formatter for decimal numbers with high precision using .NET-compatible format strings.
@@ -582,21 +650,14 @@ export declare class DotNetNumberFormatter {
     private precision;
     private sections;
     /**
-     * The set of {@link DotNetNumberStyleId} flags that control which number formats are allowed during parsing.
+     * The {@link (DotNetNumberStyles:variable)} that control which number formats are allowed during parsing.
      *
      * @example
      * ```typescript
-     * // Use predefined styles
-     * formatter.styles = DotNetNumberStyles.number;
-     *
-     * // Or combine individual flags
-     * formatter.styles = new Set([
-     *   DotNetNumberStyleId.AllowLeadingSign,
-     *   DotNetNumberStyleId.AllowDecimalPoint
-     * ]);
+     * formatter.styles = DotNetNumberStyles.allowLeadingSign | DotNetNumberStyles.allowDecimalPoint;
      * ```
      */
-    styles: DotNetNumberStyleSet;
+    styles: DotNetNumberStyles;
     /**
      * The locale settings that determine decimal/thousands separators and other culture-specific formatting.
      */
@@ -667,48 +728,129 @@ export declare class DotNetNumberFormatter {
  * ```typescript
  * // Combine individual flags
  * formatter.styles = new Set([
- *   DotNetNumberStyleId.AllowLeadingSign,
- *   DotNetNumberStyleId.AllowDecimalPoint,
- *   DotNetNumberStyleId.AllowThousands
+ *   DotNetNumberStyleFlags.AllowLeadingSign,
+ *   DotNetNumberStyleFlags.AllowDecimalPoint,
+ *   DotNetNumberStyleFlags.AllowThousands
  * ]);
  * ```
  *
  * @public
  * @category Number Styles
  */
-export declare enum DotNetNumberStyleId {
-    /** Allow currency symbol in the number string. */
-    AllowCurrencySymbol = "AllowCurrencySymbol",
+export declare const DotNetNumberStyleFlags: {
+    /** Allow leading whitespace characters. */
+    readonly allowLeadingWhite: 1;
+    /** Allow trailing whitespace characters. */
+    readonly allowTrailingWhite: 2;
+    /** Allow a leading plus (+) or minus (-) sign. */
+    readonly allowLeadingSign: 4;
+    /** Allow a trailing plus (+) or minus (-) sign. */
+    readonly allowTrailingSign: 8;
+    /** Allow parentheses to indicate negative numbers. */
+    readonly allowParentheses: 16;
     /** Allow decimal point in the number string. */
-    AllowDecimalPoint = "AllowDecimalPoint",
+    readonly allowDecimalPoint: 32;
+    /** Allow thousands separator characters. */
+    readonly allowThousands: 64;
     /** Allow exponential notation (e.g., 1.23e+10). */
-    AllowExponent = "AllowExponent",
+    readonly allowExponent: 128;
+    /** Allow currency symbol in the number string. */
+    readonly allowCurrencySymbol: 256;
     /** Parse the number as hexadecimal. */
-    AllowHexSpecifier = "AllowHexSpecifier",
+    readonly allowHexSpecifier: 512;
+};
+
+/**
+ * A set of {@link (DotNetNumberStyleFlags:variable)} flags.
+ *
+ * @public
+ * @category Number Styles
+ */
+export declare type DotNetNumberStyleFlags = (typeof DotNetNumberStyleFlags)[keyof typeof DotNetNumberStyleFlags];
+
+/**
+ * Predefined number style combinations for common parsing scenarios.
+ *
+ * @example
+ * ```typescript
+ * // Use predefined style
+ * formatter.styles = DotNetNumberStyles.number;
+ * formatter.tryFromString('1,234.56');  // Parses successfully
+ *
+ * // Use currency style
+ * formatter.styles = DotNetNumberStyles.currency;
+ * formatter.tryFromString('$1,234.56');  // Parses successfully
+ * ```
+ *
+ * @public
+ * @category Number Styles
+ */
+export declare const DotNetNumberStyles: {
+    /** No styles - only basic digits allowed. */
+    readonly none: 0;
+    readonly allowLeadingWhite: 1;
+    /** Allow trailing whitespace characters. */
+    readonly allowTrailingWhite: 2;
     /** Allow a leading plus (+) or minus (-) sign. */
-    AllowLeadingSign = "AllowLeadingSign",
-    /** Allow leading whitespace characters. */
-    AllowLeadingWhite = "AllowLeadingWhite",
+    readonly allowLeadingSign: 4;
+    /** Allow a trailing plus (+) or minus (-) sign. */
+    readonly allowTrailingSign: 8;
     /** Allow parentheses to indicate negative numbers. */
-    AllowParentheses = "AllowParentheses",
+    readonly allowParentheses: 16;
+    /** Allow decimal point in the number string. */
+    readonly allowDecimalPoint: 32;
     /** Allow thousands separator characters. */
-    AllowThousands = "AllowThousands",
-    /** Allow a trailing plus (+) or minus (-) sign. */
-    AllowTrailingSign = "AllowTrailingSign",
-    /** Allow trailing whitespace characters. */
-    AllowTrailingWhite = "AllowTrailingWhite"
-}
-
-/* Excluded from this release type: DotNetNumberStyles */
+    readonly allowThousands: 64;
+    /** Allow exponential notation (e.g., 1.23e+10). */
+    readonly allowExponent: 128;
+    /** Allow currency symbol in the number string. */
+    readonly allowCurrencySymbol: 256;
+    /** Parse the number as hexadecimal. */
+    readonly allowHexSpecifier: 512;
+    /**
+     * All styles allowed (except hex).
+     * Includes: AllowCurrencySymbol, AllowDecimalPoint, AllowExponent, AllowLeadingSign,
+     * AllowLeadingWhite, AllowParentheses, AllowThousands, AllowTrailingSign, AllowTrailingWhite.
+     */
+    readonly any: number;
+    /**
+     * Currency parsing style.
+     * Includes: AllowCurrencySymbol, AllowDecimalPoint, AllowLeadingSign, AllowLeadingWhite,
+     * AllowParentheses, AllowThousands, AllowTrailingSign, AllowTrailingWhite.
+     */
+    readonly currency: number;
+    /**
+     * Floating-point parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign,
+     * AllowDecimalPoint, AllowExponent.
+     */
+    readonly float: number;
+    /**
+     * Hexadecimal parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowHexSpecifier.
+     */
+    readonly hexNumber: number;
+    /**
+     * Basic integer parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign.
+     */
+    readonly integer: number;
+    /**
+     * Standard number parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign, AllowTrailingSign,
+     * AllowDecimalPoint, AllowThousands.
+     */
+    readonly number: number;
+};
 
 /**
- * A set of {@link DotNetNumberStyleId} flags.
+ * The type representing possible values of {@link (DotNetNumberStyles:variable)}.
+ *
+ * This includes individual {@link (DotNetNumberStyleFlags:variable)} and predefined combinations.
  *
  * @public
  * @category Number Styles
  */
-export declare type DotNetNumberStyleSet = Set<DotNetNumberStyleId>;
-
-/* Excluded from this release type: DotNetNumberStylesInfo */
+export declare type DotNetNumberStyles = (typeof DotNetNumberStyles)[keyof typeof DotNetNumberStyles];
 
 export { }

package/dist/types/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.2"
+      "packageVersion": "7.58.7"
     }
   ]
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pbkware/dot-net-date-number-formatting",
   "description": "DotNet date and number formatting library",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "sideEffects": false,
   "exports": {
@@ -49,13 +49,13 @@
     "publish": "npm publish --access=public"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.58.2",
+    "@microsoft/api-extractor": "^7.58.7",
     "del-cli": "^7.0.0",
     "lws": "^4.2.0",
     "lws-static": "^3.1.1",
     "typedoc": "^0.28.19",
-    "typescript": "^6.0.2",
-    "vitest": "^4.1.4"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
   },
   "dependencies": {
     "@pbkware/js-utils": "^0.9.1"

package/src/code/{datetime-formatter.ts → date-time-formatter.ts}

@@ -1,9 +1,8 @@
 import { Err, Ok, Result } from "@pbkware/js-utils";
 import {
-  DotNetDateTimeStyleId,
-  DotNetDateTimeStyleSet,
+  DotNetDateTimeStyleFlags,
   DotNetDateTimeStyles,
-} from "./datetime-style.js";
+} from "./date-time-styles.js";
 import { DotNetLocaleSettings } from "./locale-settings.js";
 
 type ElementType =
@@ -302,23 +301,36 @@ function tokenizeCustom(format: string): Result<Element[]> {
  */
 export class DotNetDateTimeFormatter {
   /**
-   * Set of date/time style flags that are not currently supported by this implementation.
+   * Array of date/time style flags that are not currently supported by this implementation.
    * Operations using these styles will fail.
    */
-  static readonly unsupportedStyles = new Set<DotNetDateTimeStyleId>([
-    DotNetDateTimeStyleId.AdjustToUniversal,
-    DotNetDateTimeStyleId.AssumeLocal,
-    DotNetDateTimeStyleId.AssumeUniversal,
-    DotNetDateTimeStyleId.RoundTripKind,
-  ]);
+  static readonly unsupportedStyles = [
+    DotNetDateTimeStyleFlags.adjustToUniversal,
+    DotNetDateTimeStyleFlags.assumeLocal,
+    DotNetDateTimeStyleFlags.assumeUniversal,
+    DotNetDateTimeStyleFlags.roundTripKind,
+  ];
 
   private format = "";
 
   /**
-   * The set of {@link DotNetDateTimeStyleId} flags that control date/time parsing behavior.
-   * Currently only used for future parsing functionality.
+   * The {@link (DotNetDateTimeStyles:type)} flags that control date/time parsing behavior.
+   *
+   * Use predefined combinations from {@link (DotNetDateTimeStyles:variable)} or combine
+   * {@link (DotNetDateTimeStyleFlags:variable)} using bitwise OR.
+   *
+   * @example
+   * ```typescript
+   * // Use predefined combination
+   * formatter.styles = DotNetDateTimeStyles.allowWhiteSpaces;
+   *
+   * // Combine individual flags
+   * formatter.styles =
+   *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+   *   DotNetDateTimeStyleFlags.allowTrailingWhite;
+   * ```
    */
-  styles: DotNetDateTimeStyleSet = new Set(DotNetDateTimeStyles.none);
+  styles: DotNetDateTimeStyles = DotNetDateTimeStyles.none;
 
   /**
    * The locale settings that determine date/time separators and formatting conventions.
@@ -512,13 +524,13 @@ export class DotNetDateTimeFormatter {
     let parseText = strValue;
 
     if (
-      this.styles.has(DotNetDateTimeStyleId.AllowLeadingWhite) &&
-      this.styles.has(DotNetDateTimeStyleId.AllowTrailingWhite)
+      this.styles & DotNetDateTimeStyles.allowLeadingWhite &&
+      this.styles & DotNetDateTimeStyles.allowTrailingWhite
     ) {
       parseText = parseText.trim();
-    } else if (this.styles.has(DotNetDateTimeStyleId.AllowLeadingWhite)) {
+    } else if (this.styles & DotNetDateTimeStyles.allowLeadingWhite) {
       parseText = parseText.trimStart();
-    } else if (this.styles.has(DotNetDateTimeStyleId.AllowTrailingWhite)) {
+    } else if (this.styles & DotNetDateTimeStyles.allowTrailingWhite) {
       parseText = parseText.trimEnd();
     }
 

package/src/code/date-time-styles.ts

@@ -0,0 +1,200 @@
+/**
+ * Individual style flags that control date/time parsing behavior.
+ *
+ * These flags can be combined using bitwise OR to create custom parsing rules.
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetDateTimeFormatter();
+ *
+ * // Combine multiple flags using bitwise OR
+ * formatter.styles =
+ *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+ *   DotNetDateTimeStyleFlags.allowTrailingWhite;
+ * ```
+ *
+ * @public
+ * @category DateTime Styles
+ */
+export const DotNetDateTimeStyleFlags = {
+  /** Allow leading whitespace characters. */
+  allowLeadingWhite: 1,
+
+  /** Allow trailing whitespace characters. */
+  allowTrailingWhite: 2,
+
+  /** Allow whitespace within the date/time string. */
+  allowInnerWhite: 4,
+
+  /** Do not use current date for missing date components. */
+  noCurrentDateDefault: 8,
+
+  /** Adjust date/time to UTC (not implemented). */
+  adjustToUniversal: 16,
+
+  /** Assume local time zone if not specified (not implemented). */
+  assumeLocal: 32,
+
+  /** Assume UTC time zone if not specified (not implemented). */
+  assumeUniversal: 64,
+
+  /** Preserve DateTimeKind when parsing (not implemented). */
+  roundTripKind: 128,
+} as const;
+
+/**
+ * The type representing possible values of {@link (DotNetDateTimeStyleFlags:variable)}.
+ *
+ * Flags can be combined using bitwise OR to create custom parsing behaviors.
+ *
+ * @public
+ * @category DateTime Styles
+ */
+export type DotNetDateTimeStyleFlags =
+  (typeof DotNetDateTimeStyleFlags)[keyof typeof DotNetDateTimeStyleFlags];
+
+/**
+ * Predefined date/time style combinations for common parsing scenarios.
+ *
+ * Contains individual {@link (DotNetDateTimeStyleFlags:variable)} as well as common combinations.
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetDateTimeFormatter();
+ *
+ * // Use a predefined combination
+ * formatter.styles = DotNetDateTimeStyles.allowWhiteSpaces;
+ *
+ * // Or use individual flags
+ * formatter.styles = DotNetDateTimeStyles.allowLeadingWhite;
+ *
+ * // Or combine flags manually
+ * formatter.styles =
+ *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+ *   DotNetDateTimeStyleFlags.noCurrentDateDefault;
+ * ```
+ *
+ * @category DateTime Styles
+ * @public
+ */
+export const DotNetDateTimeStyles = {
+  /** No styles - strict parsing. */
+  none: 0,
+
+  allowLeadingWhite: DotNetDateTimeStyleFlags.allowLeadingWhite,
+  allowTrailingWhite: DotNetDateTimeStyleFlags.allowTrailingWhite,
+  allowInnerWhite: DotNetDateTimeStyleFlags.allowInnerWhite,
+
+  /**
+   * Allow whitespace in date/time strings.
+   * Includes: allowLeadingWhite, allowTrailingWhite, allowInnerWhite.
+   */
+  allowWhiteSpaces:
+    DotNetDateTimeStyleFlags.allowLeadingWhite |
+    DotNetDateTimeStyleFlags.allowTrailingWhite |
+    DotNetDateTimeStyleFlags.allowInnerWhite,
+
+  noCurrentDateDefault: DotNetDateTimeStyleFlags.noCurrentDateDefault,
+
+  /** Adjust date/time to UTC (not implemented). */
+  adjustToUniversal: DotNetDateTimeStyleFlags.adjustToUniversal,
+
+  /** Assume local time zone if not specified (not implemented). */
+  assumeLocal: DotNetDateTimeStyleFlags.assumeLocal,
+
+  /** Assume UTC time zone if not specified (not implemented). */
+  assumeUniversal: DotNetDateTimeStyleFlags.assumeUniversal,
+
+  /** Preserve DateTimeKind when parsing (not implemented). */
+  roundTripKind: DotNetDateTimeStyleFlags.roundTripKind,
+} as const;
+
+/**
+ * The type representing possible values of {@link (DotNetDateTimeStyles:variable)}.
+ *
+ * This includes individual {@link (DotNetDateTimeStyleFlags:variable)} and predefined combinations.
+ *
+ * @public
+ * @category DateTime Styles
+ */
+export type DotNetDateTimeStyles =
+  (typeof DotNetDateTimeStyles)[keyof typeof DotNetDateTimeStyles];
+
+// const flagEntries = Object.entries(DotNetDateTimeStyleFlags);
+// const flagEntriesCount = flagEntries.length;
+
+// type LowercaseKeys<T extends Record<string, number>> = {
+//   [K in keyof T as Lowercase<string>]: T[K];
+// };
+
+// function lowercaseKeys<T extends Record<string, number>>(
+//   obj: T,
+// ): LowercaseKeys<T> {
+//   const result = {} as Record<string, number>;
+//   for (const key in obj) {
+//     result[key.toLowerCase()] = obj[key];
+//   }
+//   return result as LowercaseKeys<T>;
+// }
+
+// const DotNetLowerCaseDateTimeStyleFlags: LowercaseKeys<
+//   typeof DotNetDateTimeStyleFlags
+// > = lowercaseKeys(DotNetDateTimeStyleFlags);
+
+// /** @public */
+// export class DotNetDateTimeStylesStringify {
+//   static toString(styles: DotNetDateTimeStyles): string {
+//     if (styles === DotNetDateTimeStyles.none) {
+//       return "";
+//     } else {
+//       if (styles === DotNetDateTimeStyles.allowWhiteSpaces) {
+//         return "allowWhiteSpaces";
+//       } else {
+//         // For other combinations, we convert the numeric value to the corresponding flags.
+//         const keys = new Array<string>(flagEntriesCount);
+//         let count = 0;
+//         for (const [key, keyValue] of flagEntries) {
+//           if ((styles & keyValue) === keyValue) {
+//             keys[count++] = key;
+//           }
+//         }
+//         keys.length = count;
+//         return CommaText.fromStringArray(keys);
+//       }
+//     }
+//   }
+
+//   static tryFromString(value: string): Result<DotNetDateTimeStyles> {
+//     const trimmedValue = value.trim();
+//     if (trimmedValue.length === 0) {
+//       return new Ok(DotNetDateTimeStyles.none);
+//     } else {
+//       const lowerCasedValue = trimmedValue.toLowerCase();
+//       if (lowerCasedValue === "none") {
+//         return new Ok(DotNetDateTimeStyles.none);
+//       } else {
+//         if (lowerCasedValue === "allowwhitespaces") {
+//           return new Ok(DotNetDateTimeStyles.allowWhiteSpaces);
+//         } else {
+//           const toStringArrayResult = CommaText.tryToStringArray(value);
+//           if (toStringArrayResult.isErr()) {
+//             return new Err(`Invalid comma-separated list: ${value}`);
+//           } else {
+//             let result: DotNetDateTimeStyles = DotNetDateTimeStyles.none;
+//             const lowercaseFlagXmlValues =
+//               toStringArrayResult.value as (keyof typeof DotNetLowerCaseDateTimeStyleFlags)[];
+//             for (const flagXmlValue of lowercaseFlagXmlValues) {
+//               const flag = DotNetLowerCaseDateTimeStyleFlags[flagXmlValue];
+//               if (flag !== undefined) {
+//                 result |= flag;
+//               } else {
+//                 return new Err(`Invalid flag XmlValue: ${flagXmlValue}`);
+//               }
+//             }
+//             return new Ok(result);
+//           }
+//         }
+//       }
+//     }
+//   }
+// }

package/src/code/index.ts

@@ -1,5 +1,5 @@
-export * from "./datetime-formatter.js";
-export * from "./datetime-style.js";
+export * from "./date-time-formatter.js";
+export * from "./date-time-styles.js";
 export * from "./locale-settings.js";
 export * from "./number-formatter.js";
-export * from "./number-style.js";
+export * from "./number-styles.js";