@fable-org/fable-library-ts 2.0.0 → 2.1.1

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+---
+last_commit_released: 15eb83ed36657f75073fb0e1b4cac677e24fc9bb
+updaters:
+  - package.json:
+      file: package.json
+  - regex:
+      file: ./../Fable.Transforms/Global/Compiler.fs
+      pattern: (?<=let JS_LIBRARY_VERSION = ").*(?=")
+---
+
 # Changelog
 
 All notable changes to this project will be documented in this file.
@@ -5,7 +15,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## Unreleased
+## 2.1.1 - 2026-06-10
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* Reject JS-permissive date strings that .NET TryParse rejects (#4588) ([09003de](https://github.com/fable-compiler/Fable/commit/09003de8bc72e4f73281828d905d49aab7db3f55))
+* *(js/ts)* Make Exception.ToString() return the message instead of "Exception" (#4635) ([4c36f76](https://github.com/fable-compiler/Fable/commit/4c36f761bd378da800e30657c58355bd5324a653))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/63bcd3d90f37cb3934edcc59b5f54f49ffab3896..15eb83ed36657f75073fb0e1b4cac677e24fc9bb)</small></strong>
+
+## 2.1.0 - 2026-05-28
+
+### 🚀 Features
+
+* *(js/ts/python)* Add missing standard DateTime format specifiers for JS/TS and Python (#4547) ([90f5eb7](https://github.com/fable-compiler/Fable/commit/90f5eb7f61710bc679f6fdec30ff5d864984ac08))
+* *(js/ts/python)* Add missing StringBuilder.Append overloads for numeric types (#4568) ([b402c30](https://github.com/fable-compiler/Fable/commit/b402c30d04bfca8644314ba4b21894abfff6a713))
+
+### 🐞 Bug Fixes
+
+* [JS/TS] Fix DatetimeOffset.ToString("s") (#4596) ([3ce6f3f](https://github.com/fable-compiler/Fable/commit/3ce6f3fd88cc7f67e34e2bbc311e722c55ffbf45))
+* *(js/ts)* Fix datetime custom format off by one year (#4558) ([83bdbb5](https://github.com/fable-compiler/Fable/commit/83bdbb5b34e70eae203831a3a442d477d15911e1))
+* *(js/ts)* Hex format specifier uses no padding unless precision is specified (#4603) ([ba9857a](https://github.com/fable-compiler/Fable/commit/ba9857a4dcbf7ab1f936241f6619fda43e039040))
+* *(js/ts)* Fix Decimal.GetBits returning incorrect mantissa after round arithmetic result (#4561) ([345bcd4](https://github.com/fable-compiler/Fable/commit/345bcd4b99417b304c71059966126fad74cf3a97))
+* *(js/ts)* Fix G/g format specifier corrupting exponential notation when trimming trailing zeros (#4587) ([773c098](https://github.com/fable-compiler/Fable/commit/773c098a8f7ac7e8db1d4e490dec1294a80321ee))
+* *(js/ts/python)* Fix FSharpOption not recognized as union type in F# reflection (#4529) ([d78a37d](https://github.com/fable-compiler/Fable/commit/d78a37db9f4c25eb51fac8afcd320b4ea36c60a7))
+* *(ts)* Enforce browser-only compatibility in fable-library-ts tsconfig (#4563) ([10c81c1](https://github.com/fable-compiler/Fable/commit/10c81c1361208eb61f5fa78c6704e6fccc068fb1))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/b471dc16fc3b5132af77b5974d1669c9b8220cca..63bcd3d90f37cb3934edcc59b5f54f49ffab3896)</small></strong>
 
 ## 2.0.0 - 2026-04-21
 

package/Date.ts

@@ -273,13 +273,13 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
         cursorPos += tokenLength;
         switch (tokenLength) {
           case 1:
-            result += localizedDate.getFullYear() % 100;
+            result += year(localizedDate) % 100;
             break;
           case 2:
-            result += padWithZeros(localizedDate.getFullYear() % 100, 2);
+            result += padWithZeros(year(localizedDate) % 100, 2);
             break;
           default:
-            result += padWithZeros(localizedDate.getFullYear(), tokenLength);
+            result += padWithZeros(year(localizedDate), tokenLength);
             break;
         }
         break;
@@ -410,9 +410,28 @@ function dateToStringWithOffset(date: IDateTimeOffset, format?: string) {
     switch (format) {
       case "D": return dateToString_D(d);
       case "d": return dateToString_d(d);
+      case "F": return dateToString_D(d) + " " + dateToString_T(d);
+      case "f": return dateToString_D(d) + " " + dateToString_t(d);
+      case "G": return dateToString_d(d) + " " + dateToString_T(d);
+      case "g": return dateToString_d(d) + " " + dateToString_t(d);
+      case "M": case "m": return dateToString_M(d);
+      case "O": case "o": return dateToISOStringWithOffset(d, (date.offset ?? 0));
+      case "R": case "r": {
+        const utcDate = DateTime(date.getTime(), DateTimeKind.Utc);
+        return dateToString_R(utcDate);
+      }
+      case "s": return dateToString_s(toUniversalTime(d));
       case "T": return dateToString_T(toUniversalTime(d));
       case "t": return dateToString_t(toUniversalTime(d));
-      case "O": case "o": return dateToISOStringWithOffset(d, (date.offset ?? 0));
+      case "u": {
+        const utcDate = DateTime(date.getTime(), DateTimeKind.Utc);
+        return dateToString_u(utcDate);
+      }
+      case "U": {
+        const utcDate = DateTime(date.getTime(), DateTimeKind.Utc);
+        return dateToString_D(utcDate) + " " + dateToString_T(utcDate);
+      }
+      case "Y": case "y": return dateToString_Y(d);
       default: throw new Exception("Unrecognized Date print format");
     }
   } else {
@@ -444,6 +463,49 @@ function dateToString_t(date: IDateTime) {
     + ":" + padWithZeros(minute(date), 2);
 }
 
+// RFC 1123: "Thu, 01 Jan 2009 00:00:00 GMT" — always UTC
+function dateToString_R(date: IDateTime) {
+  const utcDate = toUniversalTime(date);
+  return shortDays[dayOfWeek(utcDate)] + ", "
+    + padWithZeros(day(utcDate), 2) + " "
+    + shortMonths[month(utcDate) - 1] + " "
+    + year(utcDate) + " "
+    + padWithZeros(hour(utcDate), 2) + ":"
+    + padWithZeros(minute(utcDate), 2) + ":"
+    + padWithZeros(second(utcDate), 2) + " GMT";
+}
+
+// Sortable ISO 8601, no timezone: "2009-06-15T13:45:30"
+function dateToString_s(date: IDateTime) {
+  return padWithZeros(year(date), 4) + "-"
+    + padWithZeros(month(date), 2) + "-"
+    + padWithZeros(day(date), 2) + "T"
+    + padWithZeros(hour(date), 2) + ":"
+    + padWithZeros(minute(date), 2) + ":"
+    + padWithZeros(second(date), 2);
+}
+
+// Universal sortable: "2009-06-15 13:45:30Z" — always UTC
+function dateToString_u(date: IDateTime) {
+  const utcDate = toUniversalTime(date);
+  return padWithZeros(year(utcDate), 4) + "-"
+    + padWithZeros(month(utcDate), 2) + "-"
+    + padWithZeros(day(utcDate), 2) + " "
+    + padWithZeros(hour(utcDate), 2) + ":"
+    + padWithZeros(minute(utcDate), 2) + ":"
+    + padWithZeros(second(utcDate), 2) + "Z";
+}
+
+// Month/day (InvariantCulture "MMMM dd"): "June 15"
+function dateToString_M(date: IDateTime) {
+  return longMonths[month(date) - 1] + " " + padWithZeros(day(date), 2);
+}
+
+// Year/month (InvariantCulture "yyyy MMMM"): "2009 June"
+function dateToString_Y(date: IDateTime) {
+  return year(date) + " " + longMonths[month(date) - 1];
+}
+
 function dateToStringWithKind(date: IDateTime, format?: string) {
   const utc = date.kind === DateTimeKind.Utc;
   if (typeof format !== "string") {
@@ -452,10 +514,19 @@ function dateToStringWithKind(date: IDateTime, format?: string) {
     switch (format) {
       case "D": return dateToString_D(date);
       case "d": return dateToString_d(date);
+      case "F": return dateToString_D(date) + " " + dateToString_T(date);
+      case "f": return dateToString_D(date) + " " + dateToString_t(date);
+      case "G": return dateToString_d(date) + " " + dateToString_T(date);
+      case "g": return dateToString_d(date) + " " + dateToString_t(date);
+      case "M": case "m": return dateToString_M(date);
+      case "O": case "o": return dateToISOString(date, utc);
+      case "R": case "r": return dateToString_R(date);
+      case "s": return dateToString_s(date);
       case "T": return dateToString_T(date);
       case "t": return dateToString_t(date);
-      case "O": case "o":
-        return dateToISOString(date, utc);
+      case "u": return dateToString_u(date);
+      case "U": return dateToString_D(toUniversalTime(date)) + " " + dateToString_T(toUniversalTime(date));
+      case "Y": case "y": return dateToString_Y(date);
       default:
         throw new Exception("Unrecognized Date print format");
     }
@@ -519,6 +590,18 @@ export function maxValue() {
   return DateTime(253402300799999, DateTimeKind.Utc);
 }
 
+// The only date words .NET's invariant parser recognises: month names, weekday names,
+// meridiem designators and zone markers (plus the ISO "T" separator). Anything else is
+// rejected. Used to reject JS-permissive inputs (see `parseRaw`).
+const recognizedDateWords = new Set([
+  "january", "february", "march", "april", "may", "june",
+  "july", "august", "september", "october", "november", "december",
+  "jan", "feb", "mar", "apr", "jun", "jul", "aug", "sep", "sept", "oct", "nov", "dec",
+  "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday",
+  "mon", "tue", "wed", "thu", "fri", "sat", "sun",
+  "am", "pm", "gmt", "utc", "ut", "t", "z",
+]);
+
 export function parseRaw(input: string): [Date, Offset] {
   function fail() {
     throw new Exception(`The string is not a valid Date: ${input}`);
@@ -528,6 +611,10 @@ export function parseRaw(input: string): [Date, Offset] {
     fail();
   }
 
+  if ((input.match(/[a-z]+/gi) ?? []).some(word => !recognizedDateWords.has(word.toLowerCase()))) {
+    fail();
+  }
+
   // ISO dates without TZ are parsed as UTC. Adding time without TZ keeps them local.
   if (input.length === 10 && input[4] === "-" && input[7] === "-") {
     input += "T00:00:00";

package/Decimal.ts

@@ -248,14 +248,16 @@ export function fromParts(low: number, mid: number, high: number, isNegative: bo
 
 export function getBits(d: Decimal) {
   const bitSize = 96;
-  const decDigits = Uint8Array.from(d.c);
+  const decStr = d.toString();
+  const absStr = decStr[0] === "-" ? decStr.slice(1) : decStr;
+  const dotPos = absStr.indexOf(".");
+  const scale = dotPos < 0 ? 0 : absStr.length - dotPos - 1;
+  const mantissaStr = absStr.replace(".", "");
+  const decDigits = Uint8Array.from(mantissaStr, ch => ch.charCodeAt(0) - 48);
   const hexDigits = decimalToHex(decDigits, bitSize);
   const low = getInt32Bits(hexDigits, 0);
   const mid = getInt32Bits(hexDigits, 8);
   const high = getInt32Bits(hexDigits, 16);
-  const decStr = d.toString();
-  const dotPos = decStr.indexOf(".");
-  const scale = dotPos < 0 ? 0 : decStr.length - dotPos - 1;
   const signExp = ((scale & 0x7F) << 16) | (d.s < 0 ? 0x80000000 : 0);
   return [low, mid, high, signExp];
 }

package/Reflection.ts

@@ -1,6 +1,7 @@
 import { FSharpRef, Record, Union } from "./Types.ts";
 import { Exception, MutableArray, combineHashCodes, equalArraysWith, IEquatable, stringHash } from "./Util.ts";
 import Decimal from "./Decimal.ts";
+import { Some, some } from "./Option.ts";
 
 export type FieldInfo = [string, TypeInfo];
 export type PropertyInfo = FieldInfo;
@@ -155,7 +156,18 @@ export function lambda_type(argType: TypeInfo, returnType: TypeInfo): TypeInfo {
 }
 
 export function option_type(generic: TypeInfo): TypeInfo {
-  return new TypeInfo("Microsoft.FSharp.Core.FSharpOption`1", [generic]);
+  const t: TypeInfo = new TypeInfo(
+    "Microsoft.FSharp.Core.FSharpOption`1",
+    [generic],
+    undefined,
+    undefined,
+    undefined,
+    () => [
+      new CaseInfo(t, 0, "None"),
+      new CaseInfo(t, 1, "Some", [["value", generic]])
+    ]
+  );
+  return t;
 }
 
 export function list_type(generic: TypeInfo): TypeInfo {
@@ -443,6 +455,15 @@ export function isFunction(t: TypeInfo): boolean {
 
 export function getUnionFields(v: any, t: TypeInfo): [CaseInfo, any[]] {
   const cases = getUnionCases(t);
+  // Special handling for option types (None is undefined, Some is the value or a Some wrapper)
+  if (t.fullname === "Microsoft.FSharp.Core.FSharpOption`1") {
+    if (v == null) {
+      return [cases[0], []]; // None case
+    } else {
+      const innerValue = v instanceof Some ? v.value : v;
+      return [cases[1], [innerValue]]; // Some case
+    }
+  }
   const case_ = cases[v.tag];
   if (case_ == null) {
     throw new Exception(`Cannot find case ${v.name} in union type`);
@@ -478,6 +499,10 @@ export function makeUnion(uci: CaseInfo, values: MutableArray<any>): any {
   if (values.length !== expectedLength) {
     throw new Exception(`Expected an array of length ${expectedLength} but got ${values.length}`);
   }
+  // Special handling for option types
+  if (uci.declaringType.fullname === "Microsoft.FSharp.Core.FSharpOption`1") {
+    return uci.tag === 0 ? undefined : some(values[0]);
+  }
   const construct = uci.declaringType.construct;
   if (construct == null) {
     return {};

package/String.ts

@@ -390,11 +390,23 @@ export function format(str: string | object, ...args: any[]) {
             rep = parts.integral + "." + padRight(parts.decimal, precision, "0");
           }
           break;
-        case "g": case "G":
+        case "g": case "G": {
           rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);
-          // TODO: Check why some numbers are formatted with decimal part
-          rep = trimEnd(trimEnd(rep, "0"), ".");
+          // Handle exponential notation: only trim trailing zeros from mantissa, not from exponent.
+          // .NET G format guarantees an exponent of at least 2 digits with an explicit sign (e.g. "E-07").
+          const eIdx = rep.indexOf("e");
+          if (eIdx >= 0) {
+            const mantissa = trimEnd(trimEnd(rep.slice(0, eIdx), "0"), ".");
+            const expSign = rep[eIdx + 1]; // toPrecision always emits "+" or "-"
+            const expDigits = rep.slice(eIdx + 2);
+            const paddedExpDigits = expDigits.length < 2 ? "0" + expDigits : expDigits;
+            const eChar = format === "G" ? "E" : "e";
+            rep = mantissa + eChar + expSign + paddedExpDigits;
+          } else {
+            rep = trimEnd(trimEnd(rep, "0"), ".");
+          }
           break;
+        }
         case "n": case "N":
           precision = precision != null ? precision : 2;
           rep = toFixed(rep, precision);
@@ -421,7 +433,7 @@ export function format(str: string | object, ...args: any[]) {
           if (!isIntegral(rep)) {
             throw new Exception("Format specifier was invalid.");
           }
-          precision = precision != null ? precision : 2;
+          precision = precision != null ? precision : 1;
           rep = padLeft(toHex(rep), precision, "0");
           if (format === "X") {
             rep = rep.toUpperCase();

package/System.Text.ts

@@ -1,9 +1,10 @@
 
 import { replace, format, replicate, substring, isNullOrEmpty, join } from "./String.ts";
-import { float64, int32 } from "./Int32.ts";
+import { float64, float32, uint32, uint16, int16, uint8, int8, int32 } from "./Int32.ts";
 import { class_type, TypeInfo } from "./Reflection.ts";
 import { toString } from "./Types.ts";
-import { Exception, clear, MutableArray, int32ToString } from "./Util.ts";
+import { Exception, clear, MutableArray, int64ToString, int32ToString, int16ToString } from "./Util.ts";
+import { uint64, int64 } from "./BigInt.ts";
 import { setItem, item } from "./Array.ts";
 
 export class StringBuilder {
@@ -61,11 +62,51 @@ export function StringBuilder__Append_61B1CA(x: StringBuilder, c: string, repeat
     return x;
 }
 
+export function StringBuilder__Append_Z510FF069(x: StringBuilder, o: int8): StringBuilder {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+
+export function StringBuilder__Append_244D3E44(x: StringBuilder, o: uint8): StringBuilder {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+
+export function StringBuilder__Append_Z524259E6(x: StringBuilder, o: int16): StringBuilder {
+    void (x.buf.push(int16ToString(o)));
+    return x;
+}
+
+export function StringBuilder__Append_Z6EF82811(x: StringBuilder, o: uint16): StringBuilder {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+
 export function StringBuilder__Append_Z524259A4(x: StringBuilder, o: int32): StringBuilder {
     void (x.buf.push(int32ToString(o)));
     return x;
 }
 
+export function StringBuilder__Append_Z6EF827D7(x: StringBuilder, o: uint32): StringBuilder {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+
+export function StringBuilder__Append_Z524259C1(x: StringBuilder, o: int64): StringBuilder {
+    void (x.buf.push(int64ToString(o)));
+    return x;
+}
+
+export function StringBuilder__Append_Z6EF827B6(x: StringBuilder, o: uint64): StringBuilder {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+
+export function StringBuilder__Append_Z7138B98C(x: StringBuilder, o: float32): StringBuilder {
+    void (x.buf.push(o.toString()));
+    return x;
+}
+
 export function StringBuilder__Append_5E38073B(x: StringBuilder, o: float64): StringBuilder {
     void (x.buf.push(o.toString()));
     return x;

package/Util.ts

@@ -84,6 +84,10 @@ export class Exception {
   constructor(msg?: string) {
     this.message = msg ?? "";
   }
+
+  toString() {
+    return this.message;
+  }
 }
 
 export function isException(x: any) {

package/package.json

@@ -3,7 +3,7 @@
     "private": false,
     "type": "module",
     "name": "@fable-org/fable-library-ts",
-    "version": "2.0.0",
+    "version": "2.1.1",
     "description": "Core library used by F# projects compiled with fable.io",
     "author": "Fable Contributors",
     "license": "MIT",

package/tsconfig.json

@@ -34,7 +34,7 @@
     // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
     // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
     // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    "types": [],                                         /* Exclude all @types/* packages (e.g. @types/node) to enforce browser-only compatibility. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
     // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
     // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */