@fable-org/fable-library-ts 1.10.0 → 2.0.0-beta.2

package/Date.ts

@@ -55,7 +55,7 @@ function parseNextChar(format: string, pos: number) {
   return format.charCodeAt(pos + 1);
 }
 
-function parseQuotedString(format: string, pos: number) : [string, number] {
+function parseQuotedString(format: string, pos: number): [string, number] {
   let beginPos = pos;
   // Get the character used to quote the string
   const quoteChar = format[pos];
@@ -114,9 +114,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += shortDays[dayOfWeek(localizedDate)];
             break;
           case 4:
-            result += longDays[dayOfWeek(localizedDate)];
-            break;
           default:
+            result += longDays[dayOfWeek(localizedDate)];
             break;
         }
         break;
@@ -132,7 +131,9 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
           // milliseconds provided to it.
           // This is to have the same behavior as .NET when doing:
           // DateTime(1, 2, 3, 4, 5, 6, DateTimeKind.Utc).ToString("fffff") => 00000
-          result += (""+millisecond(localizedDate)).padEnd(tokenLength, "0");
+          result += ("" + millisecond(localizedDate)).padEnd(tokenLength, "0");
+        } else {
+          throw "Input string was not in a correct format.";
         }
         break;
       case "F":
@@ -152,14 +153,14 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
           if (value != 0) {
             result += padWithZeros(value, 3);
           }
+        } else {
+          throw "Input string was not in a correct format.";
         }
         break;
       case "g":
         tokenLength = parseRepeatToken(format, cursorPos, "g");
         cursorPos += tokenLength;
-        if (tokenLength <= 2) {
-          result += "A.D.";
-        }
+        result += "A.D.";
         break;
       case "h":
         tokenLength = parseRepeatToken(format, cursorPos, "h");
@@ -170,11 +171,10 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += h1Value ? h1Value : 12;
             break;
           case 2:
+          default:
             const h2Value = hour(localizedDate) % 12;
             result += padWithZeros(h2Value ? h2Value : 12, 2);
             break;
-          default:
-            break;
         }
         break;
       case "H":
@@ -185,9 +185,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += hour(localizedDate);
             break;
           case 2:
-            result += padWithZeros(hour(localizedDate), 2);
-            break;
           default:
+            result += padWithZeros(hour(localizedDate), 2);
             break;
         }
         break;
@@ -219,9 +218,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += minute(localizedDate);
             break;
           case 2:
-            result += padWithZeros(minute(localizedDate), 2);
-            break;
           default:
+            result += padWithZeros(minute(localizedDate), 2);
             break;
         }
         break;
@@ -239,9 +237,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += shortMonths[month(localizedDate) - 1];
             break;
           case 4:
-            result += longMonths[month(localizedDate) - 1];
-            break;
           default:
+            result += longMonths[month(localizedDate) - 1];
             break;
         }
         break;
@@ -253,9 +250,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += second(localizedDate);
             break;
           case 2:
-            result += padWithZeros(second(localizedDate), 2);
-            break;
           default:
+            result += padWithZeros(second(localizedDate), 2);
             break;
         }
         break;
@@ -267,9 +263,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
             result += localizedDate.getHours() < 12 ? "A" : "P";
             break;
           case 2:
-            result += localizedDate.getHours() < 12 ? "AM" : "PM";
-            break;
           default:
+            result += localizedDate.getHours() < 12 ? "AM" : "PM";
             break;
         }
         break;
@@ -283,16 +278,8 @@ function dateToStringWithCustomFormat(date: Date, format: string, utc: boolean)
           case 2:
             result += padWithZeros(localizedDate.getFullYear() % 100, 2);
             break;
-          case 3:
-            result += padWithZeros(localizedDate.getFullYear(), 3);
-            break;
-          case 4:
-            result += padWithZeros(localizedDate.getFullYear(), 4);
-            break;
-          case 5:
-            result += padWithZeros(localizedDate.getFullYear(), 5);
-            break;
           default:
+            result += padWithZeros(localizedDate.getFullYear(), tokenLength);
             break;
         }
         break;
@@ -393,13 +380,6 @@ export function dateOffsetToString(offset: number) {
     padWithZeros(minutes, 2);
 }
 
-export function dateToHalfUTCString(date: IDateTime, half: "first" | "second") {
-  const str = date.toISOString();
-  return half === "first"
-    ? str.substring(0, str.indexOf("T"))
-    : str.substring(str.indexOf("T") + 1, str.length - 1);
-}
-
 function dateToISOString(d: IDateTime, utc: boolean) {
   if (utc) {
     return d.toISOString();
@@ -428,8 +408,10 @@ function dateToStringWithOffset(date: IDateTimeOffset, format?: string) {
     return d.toISOString().replace(/\.\d+/, "").replace(/[A-Z]|\.\d+/g, " ") + dateOffsetToString((date.offset ?? 0));
   } else if (format.length === 1) {
     switch (format) {
-      case "D": case "d": return dateToHalfUTCString(d, "first");
-      case "T": case "t": return dateToHalfUTCString(d, "second");
+      case "D": return dateToString_D(d);
+      case "d": return dateToString_d(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));
       default: throw new Error("Unrecognized Date print format");
     }
@@ -438,16 +420,40 @@ function dateToStringWithOffset(date: IDateTimeOffset, format?: string) {
   }
 }
 
+function dateToString_D(date: IDateTime) {
+  return longDays[dayOfWeek(date)]
+    + ", " + padWithZeros(day(date), 2)
+    + " " + longMonths[month(date) - 1]
+    + " " + year(date);
+}
+
+function dateToString_d(date: IDateTime) {
+  return padWithZeros(month(date), 2)
+    + "/" + padWithZeros(day(date), 2)
+    + "/" + year(date);
+}
+
+function dateToString_T(date: IDateTime) {
+  return padWithZeros(hour(date), 2)
+    + ":" + padWithZeros(minute(date), 2)
+    + ":" + padWithZeros(second(date), 2);
+}
+
+function dateToString_t(date: IDateTime) {
+  return padWithZeros(hour(date), 2)
+    + ":" + padWithZeros(minute(date), 2);
+}
+
 function dateToStringWithKind(date: IDateTime, format?: string) {
   const utc = date.kind === DateKind.UTC;
   if (typeof format !== "string") {
     return utc ? date.toUTCString() : date.toLocaleString();
   } else if (format.length === 1) {
     switch (format) {
-      case "D": case "d":
-        return utc ? dateToHalfUTCString(date, "first") : date.toLocaleDateString();
-      case "T": case "t":
-        return utc ? dateToHalfUTCString(date, "second") : date.toLocaleTimeString();
+      case "D": return dateToString_D(date);
+      case "d": return dateToString_d(date);
+      case "T": return dateToString_T(date);
+      case "t": return dateToString_t(date);
       case "O": case "o":
         return dateToISOString(date, utc);
       default:

package/Decimal.ts

@@ -2,6 +2,9 @@ import Decimal, { BigSource } from "./lib/big.js";
 import { Numeric, symbol } from "./Numeric.js";
 import { FSharpRef } from "./Types.js";
 import { combineHashCodes } from "./Util.js";
+import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
+import { fromDecimal, int64, uint64, int128, uint128, nativeint, unativeint } from "./BigInt.js";
+import * as bigInt from "./BigInt.js";
 
 Decimal.prototype.GetHashCode = function () {
   return combineHashCodes([this.s, this.e].concat(this.c))
@@ -139,10 +142,35 @@ export function parse(str: string): Decimal {
   }
 }
 
-export function toNumber(x: Decimal) {
+export function toNumber(x: Decimal): number {
   return +x;
 }
 
+export function toChar(x: Decimal): string {
+  const n = toNumber(x);
+  if (n < 0 || n > 65535 || isNaN(n)) {
+    throw new Error("Value was either too large or too small for a character.");
+  }
+  return String.fromCharCode(n);
+}
+
+export function toInt8(x: Decimal): int8 { return bigInt.toInt8(fromDecimal(x)); }
+export function toUInt8(x: Decimal): uint8 { return bigInt.toUInt8(fromDecimal(x)); }
+export function toInt16(x: Decimal): int16 { return bigInt.toInt16(fromDecimal(x)); }
+export function toUInt16(x: Decimal): uint16 { return bigInt.toUInt16(fromDecimal(x)); }
+export function toInt32(x: Decimal): int32 { return bigInt.toInt32(fromDecimal(x)); }
+export function toUInt32(x: Decimal): uint32 { return bigInt.toUInt32(fromDecimal(x)); }
+export function toInt64(x: Decimal): int64 { return bigInt.toInt64(fromDecimal(x)); }
+export function toUInt64(x: Decimal): uint64 { return bigInt.toUInt64(fromDecimal(x)); }
+export function toInt128(x: Decimal): int128 { return bigInt.toInt128(fromDecimal(x)); }
+export function toUInt128(x: Decimal): uint128 { return bigInt.toUInt128(fromDecimal(x)); }
+export function toNativeInt(x: Decimal): nativeint { return bigInt.toNativeInt(fromDecimal(x)); }
+export function toUNativeInt(x: Decimal): unativeint { return bigInt.toUNativeInt(fromDecimal(x)); }
+
+export function toFloat16(x: Decimal): float16 { return toNumber(x); }
+export function toFloat32(x: Decimal): float32 { return toNumber(x); }
+export function toFloat64(x: Decimal): float64 { return toNumber(x); }
+
 function decimalToHex(dec: Uint8Array, bitSize: number) {
   const hex = new Uint8Array(bitSize / 4 | 0);
   let hexCount = 1;

package/FSharp.Collections.ts

@@ -1,34 +1,34 @@
-import { int32 } from "./Int32.js";
-import { compare, IComparer, physicalHash, equals, structuralHash, IEqualityComparer } from "./Util.js";
-
-export function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T> {
-    return {
-        Equals(x: T, y: T): boolean {
-            return eq(x, y);
-        },
-        GetHashCode(x_1: T): int32 {
-            return hash(x_1);
-        },
-    };
-}
-
-export function HashIdentity_Structural<T>(): IEqualityComparer<T> {
-    return HashIdentity_FromFunctions<T>(structuralHash, equals);
-}
-
-export function HashIdentity_Reference<T>(): IEqualityComparer<T> {
-    return HashIdentity_FromFunctions<T>(physicalHash, (e: T, e_1: T): boolean => (e === e_1));
-}
-
-export function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T> {
-    return {
-        Compare(x: T, y: T): int32 {
-            return comparer(x, y);
-        },
-    };
-}
-
-export function ComparisonIdentity_Structural<T>(): IComparer<T> {
-    return ComparisonIdentity_FromFunction<T>(compare);
-}
-
+import { int32 } from "./Int32.js";
+import { compare, IComparer, physicalHash, equals, structuralHash, IEqualityComparer } from "./Util.js";
+
+export function HashIdentity_FromFunctions<T>(hash: ((arg0: T) => int32), eq: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T> {
+    return {
+        Equals(x: T, y: T): boolean {
+            return eq(x, y);
+        },
+        GetHashCode(x_1: T): int32 {
+            return hash(x_1) | 0;
+        },
+    };
+}
+
+export function HashIdentity_Structural<T>(): IEqualityComparer<T> {
+    return HashIdentity_FromFunctions<T>((obj: T): int32 => (structuralHash(obj) | 0), equals);
+}
+
+export function HashIdentity_Reference<T>(): IEqualityComparer<T> {
+    return HashIdentity_FromFunctions<T>((obj: T): int32 => (physicalHash(obj) | 0), (e: T, e_1: T): boolean => (e === e_1));
+}
+
+export function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T> {
+    return {
+        Compare(x: T, y: T): int32 {
+            return comparer(x, y) | 0;
+        },
+    };
+}
+
+export function ComparisonIdentity_Structural<T>(): IComparer<T> {
+    return ComparisonIdentity_FromFunction<T>((e: T, e_1: T): int32 => (compare(e, e_1) | 0));
+}
+

package/FSharp.Core.CompilerServices.ts

@@ -1,37 +1,37 @@
-import { class_type, TypeInfo } from "./Reflection.js";
-import { addRangeInPlace } from "./Array.js";
-import { toList } from "./Seq.js";
-import { FSharpList } from "./List.js";
-
-export class ListCollector$1<T> {
-    readonly collector: T[];
-    constructor() {
-        this.collector = [];
-    }
-}
-
-export function ListCollector$1_$reflection(gen0: TypeInfo): TypeInfo {
-    return class_type("Microsoft.FSharp.Core.CompilerServices.ListCollector`1", [gen0], ListCollector$1);
-}
-
-export function ListCollector$1_$ctor<T>(): ListCollector$1<T> {
-    return new ListCollector$1();
-}
-
-export function ListCollector$1__Add_2B595<T>(this$: ListCollector$1<T>, value: T): void {
-    void (this$.collector.push(value));
-}
-
-export function ListCollector$1__AddMany_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): void {
-    addRangeInPlace(values, this$.collector);
-}
-
-export function ListCollector$1__AddManyAndClose_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): FSharpList<T> {
-    addRangeInPlace(values, this$.collector);
-    return toList<T>(this$.collector);
-}
-
-export function ListCollector$1__Close<T>(this$: ListCollector$1<T>): FSharpList<T> {
-    return toList<T>(this$.collector);
-}
-
+import { class_type, TypeInfo } from "./Reflection.js";
+import { addRangeInPlace } from "./Array.js";
+import { toList } from "./Seq.js";
+import { FSharpList } from "./List.js";
+
+export class ListCollector$1<T> {
+    readonly collector: T[];
+    constructor() {
+        this.collector = [];
+    }
+}
+
+export function ListCollector$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return class_type("Microsoft.FSharp.Core.CompilerServices.ListCollector`1", [gen0], ListCollector$1);
+}
+
+export function ListCollector$1_$ctor<T>(): ListCollector$1<T> {
+    return new ListCollector$1();
+}
+
+export function ListCollector$1__Add_2B595<T>(this$: ListCollector$1<T>, value: T): void {
+    void (this$.collector.push(value));
+}
+
+export function ListCollector$1__AddMany_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): void {
+    addRangeInPlace(values, this$.collector);
+}
+
+export function ListCollector$1__AddManyAndClose_BB573A<T>(this$: ListCollector$1<T>, values: Iterable<T>): FSharpList<T> {
+    addRangeInPlace(values, this$.collector);
+    return toList<T>(this$.collector);
+}
+
+export function ListCollector$1__Close<T>(this$: ListCollector$1<T>): FSharpList<T> {
+    return toList<T>(this$.collector);
+}
+