@fable-org/fable-library-ts 2.0.0-beta.3 → 2.0.0-beta.5

package/DateOnly.ts

@@ -1,9 +1,9 @@
-import { FSharpRef } from "./Types.js";
-import { DateTime, getTicks, dayOfYear as Date_dayOfYear, year as Date_year, month as Date_month, day as Date_day, daysInMonth as Date_daysInMonth, ticksToUnixEpochMilliseconds } from "./Date.js";
-import { IDateTime, DateKind, padWithZeros } from "./Util.js";
+import { FSharpRef } from "./Types.ts";
+import { DateTime, getTicks, dayOfYear as Date_dayOfYear, year as Date_year, month as Date_month, day as Date_day, daysInMonth as Date_daysInMonth, ticksToUnixEpochMilliseconds } from "./Date.ts";
+import { Exception, IDateTime, DateTimeKind, padWithZeros } from "./Util.ts";
 
 export function fromUnixMilliseconds(value: number) {
-  return DateTime(value, DateKind.UTC);
+  return DateTime(value, DateTimeKind.Utc);
 }
 
 export function create(year: number, month: number, day: number) {
@@ -57,13 +57,13 @@ export function dayOfYear(d: IDateTime) {
   return Date_dayOfYear(d);
 }
 
-export function toDateTime(d: IDateTime, time: number, kind = DateKind.Unspecified) {
-  return DateTime(d.getTime() + time + (kind !== DateKind.UTC ? d.getTimezoneOffset() : 0) * 60000, kind);
+export function toDateTime(d: IDateTime, time: number, kind: DateTimeKind = DateTimeKind.Unspecified) {
+  return DateTime(d.getTime() + time + (kind !== DateTimeKind.Utc ? d.getTimezoneOffset() : 0) * 60_000, kind);
 }
 
 export function toString(d: IDateTime, format = "d", _provider?: any) {
   if (["d", "o", "O"].indexOf(format) === -1) {
-    throw new Error("Custom formats are not supported");
+    throw new Exception("Custom formats are not supported");
   }
 
   const y = padWithZeros(year(d), 4);
@@ -75,7 +75,7 @@ export function toString(d: IDateTime, format = "d", _provider?: any) {
 
 export function parse(str: string) {
   function fail(): IDateTime {
-    throw new Error(`String '${str}' was not recognized as a valid DateOnly.`);
+    throw new Exception(`String '${str}' was not recognized as a valid DateOnly.`);
   }
 
   // Allowed separators: . , / -

package/Decimal.ts

@@ -1,10 +1,10 @@
 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";
+import { Numeric, symbol } from "./Numeric.ts";
+import { FSharpRef } from "./Types.ts";
+import { Exception, combineHashCodes } from "./Util.ts";
+import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.ts";
+import { fromDecimal, int64, uint64, int128, uint128, nativeint, unativeint } from "./BigInt.ts";
+import * as bigInt from "./BigInt.ts";
 
 Decimal.prototype.GetHashCode = function () {
   return combineHashCodes([this.s, this.e].concat(this.c))
@@ -138,7 +138,7 @@ export function parse(str: string): Decimal {
   if (tryParse(str, defValue)) {
     return defValue.contents;
   } else {
-    throw new Error(`The input string ${str} was not in a correct format.`);
+    throw new Exception(`The input string ${str} was not in a correct format.`);
   }
 }
 
@@ -149,7 +149,7 @@ export function toNumber(x: Decimal): number {
 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.");
+    throw new Exception("Value was either too large or too small for a character.");
   }
   return String.fromCharCode(n);
 }
@@ -263,7 +263,7 @@ export function getBits(d: Decimal) {
 // export function makeRangeStepFunction(step: Decimal, last: Decimal) {
 //   const stepComparedWithZero = step.cmp(get_Zero);
 //   if (stepComparedWithZero === 0) {
-//     throw new Error("The step of a range cannot be zero");
+//     throw new Exception("The step of a range cannot be zero");
 //   }
 //   const stepGreaterThanZero = stepComparedWithZero > 0;
 //   return (x: Decimal) => {

package/Double.ts

@@ -1,4 +1,5 @@
-import { FSharpRef } from "./Types.js";
+import { FSharpRef } from "./Types.ts";
+import { Exception } from "./Util.ts";
 
 export function tryParse(str: string, defValue: FSharpRef<number>): boolean {
   // TODO: test if value is valid and in range
@@ -17,7 +18,7 @@ export function parse(str: string): number {
   if (tryParse(str, defValue)) {
     return defValue.contents;
   } else {
-    throw new Error(`The input string ${str} was not in a correct format.`);
+    throw new Exception(`The input string ${str} was not in a correct format.`);
   }
 }
 

package/Encoding.ts

@@ -1,4 +1,4 @@
-import { uint8 } from "./Int32.js";
+import { uint8 } from "./Int32.ts";
 
 const littleEndian = true;
 

package/Event.ts

@@ -1,6 +1,6 @@
-import { IObservable, subscribe } from "./Observable.js";
-import { Option, some, value } from "./Option.js";
-import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.js";
+import { IObservable, subscribe } from "./Observable.ts";
+import { Option, some, value } from "./Option.ts";
+import { FSharpChoice$2_$union, Choice_tryValueIfChoice1Of2, Choice_tryValueIfChoice2Of2 } from "./Choice.ts";
 
 export type Handler<T> = (sender: any, x: T) => void;
 

package/FSharp.Collections.ts

@@ -1,34 +1,53 @@
-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));
-}
-
+
+import { int32 } from "./Int32.ts";
+import { compare, IComparer, physicalHash, equals as equals_1, structuralHash, IEqualityComparer } from "./Util.ts";
+
+export function HashIdentity_FromFunctions<T>(hasher: ((arg0: T) => int32), equals: ((arg0: T, arg1: T) => boolean)): IEqualityComparer<T> {
+    return {
+        GetHashCode(x: T): int32 {
+            return hasher(x) | 0;
+        },
+        Equals(x_1: T, y: T): boolean {
+            return (x_1 == null) ? (y == null) : ((y == null) ? false : equals(x_1, y));
+        },
+    };
+}
+
+export function HashIdentity_Structural<T>(): IEqualityComparer<T> {
+    return {
+        GetHashCode(x: T): int32 {
+            return structuralHash(x) | 0;
+        },
+        Equals(x_1: T, y: T): boolean {
+            return equals_1(x_1, y);
+        },
+    };
+}
+
+export function HashIdentity_Reference<T>(): IEqualityComparer<T> {
+    return {
+        GetHashCode(x: T): int32 {
+            return physicalHash(x) | 0;
+        },
+        Equals(x_1: T, y: T): boolean {
+            return equals_1(x_1, y);
+        },
+    };
+}
+
+export function ComparisonIdentity_FromFunction<T>(comparer: ((arg0: T, arg1: T) => int32)): IComparer<T> {
+    return {
+        Compare(x: T, y: T): int32 {
+            return ((x == null) ? ((y == null) ? 0 : -1) : ((y == null) ? 1 : comparer(x, y))) | 0;
+        },
+    };
+}
+
+export function ComparisonIdentity_Structural<T>(): IComparer<T> {
+    return {
+        Compare(x: T, y: T): int32 {
+            return compare(x, y) | 0;
+        },
+    };
+}
+

package/FSharp.Core.CompilerServices.ts

@@ -1,37 +1,38 @@
-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.ts";
+import { addRangeInPlace } from "./Array.ts";
+import { toList } from "./Seq.ts";
+import { FSharpList } from "./List.ts";
+
+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);
+}
+