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

package/System.ts

@@ -0,0 +1,366 @@
+
+import { Exception } from "./Util.ts";
+import { class_type, TypeInfo } from "./Reflection.ts";
+import { SR_Arg_ArgumentOutOfRangeException, SR_ArgumentNull_Generic, SR_Arg_ArgumentException, SR_Arg_ParamName_Name, SR_Arg_TimeoutException, SR_Arg_StackOverflowException, SR_Arg_RankException, SR_Arg_OverflowException, SR_Arg_OutOfMemoryException, SR_Arg_NullReferenceException, SR_Arg_NotSupportedException, SR_Arg_NotImplementedException, SR_Arg_NotFiniteNumberException, SR_Arg_InvalidOperationException, SR_Arg_IndexOutOfRangeException, SR_Arg_FormatException, SR_Arg_DivideByZero, SR_Arg_ArithmeticException, SR_Arg_ApplicationException, SR_Arg_SystemException } from "./Global.ts";
+import { isNullOrEmpty } from "./String.ts";
+
+export class SystemException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function SystemException_$reflection(): TypeInfo {
+    return class_type("System.SystemException", undefined, SystemException, class_type("System.Exception"));
+}
+
+export function SystemException_$ctor_Z721C83C5(message: string): SystemException {
+    return new SystemException(message);
+}
+
+export function SystemException_$ctor(): SystemException {
+    return SystemException_$ctor_Z721C83C5(SR_Arg_SystemException);
+}
+
+export class ApplicationException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function ApplicationException_$reflection(): TypeInfo {
+    return class_type("System.ApplicationException", undefined, ApplicationException, class_type("System.Exception"));
+}
+
+export function ApplicationException_$ctor_Z721C83C5(message: string): ApplicationException {
+    return new ApplicationException(message);
+}
+
+export function ApplicationException_$ctor(): ApplicationException {
+    return ApplicationException_$ctor_Z721C83C5(SR_Arg_ApplicationException);
+}
+
+export class ArithmeticException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function ArithmeticException_$reflection(): TypeInfo {
+    return class_type("System.ArithmeticException", undefined, ArithmeticException, class_type("System.Exception"));
+}
+
+export function ArithmeticException_$ctor_Z721C83C5(message: string): ArithmeticException {
+    return new ArithmeticException(message);
+}
+
+export function ArithmeticException_$ctor(): ArithmeticException {
+    return ArithmeticException_$ctor_Z721C83C5(SR_Arg_ArithmeticException);
+}
+
+export class DivideByZeroException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function DivideByZeroException_$reflection(): TypeInfo {
+    return class_type("System.DivideByZeroException", undefined, DivideByZeroException, class_type("System.Exception"));
+}
+
+export function DivideByZeroException_$ctor_Z721C83C5(message: string): DivideByZeroException {
+    return new DivideByZeroException(message);
+}
+
+export function DivideByZeroException_$ctor(): DivideByZeroException {
+    return DivideByZeroException_$ctor_Z721C83C5(SR_Arg_DivideByZero);
+}
+
+export class FormatException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function FormatException_$reflection(): TypeInfo {
+    return class_type("System.FormatException", undefined, FormatException, class_type("System.Exception"));
+}
+
+export function FormatException_$ctor_Z721C83C5(message: string): FormatException {
+    return new FormatException(message);
+}
+
+export function FormatException_$ctor(): FormatException {
+    return FormatException_$ctor_Z721C83C5(SR_Arg_FormatException);
+}
+
+export class IndexOutOfRangeException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function IndexOutOfRangeException_$reflection(): TypeInfo {
+    return class_type("System.IndexOutOfRangeException", undefined, IndexOutOfRangeException, class_type("System.Exception"));
+}
+
+export function IndexOutOfRangeException_$ctor_Z721C83C5(message: string): IndexOutOfRangeException {
+    return new IndexOutOfRangeException(message);
+}
+
+export function IndexOutOfRangeException_$ctor(): IndexOutOfRangeException {
+    return IndexOutOfRangeException_$ctor_Z721C83C5(SR_Arg_IndexOutOfRangeException);
+}
+
+export class InvalidOperationException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function InvalidOperationException_$reflection(): TypeInfo {
+    return class_type("System.InvalidOperationException", undefined, InvalidOperationException, class_type("System.Exception"));
+}
+
+export function InvalidOperationException_$ctor_Z721C83C5(message: string): InvalidOperationException {
+    return new InvalidOperationException(message);
+}
+
+export function InvalidOperationException_$ctor(): InvalidOperationException {
+    return InvalidOperationException_$ctor_Z721C83C5(SR_Arg_InvalidOperationException);
+}
+
+export class NotFiniteNumberException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function NotFiniteNumberException_$reflection(): TypeInfo {
+    return class_type("System.NotFiniteNumberException", undefined, NotFiniteNumberException, class_type("System.Exception"));
+}
+
+export function NotFiniteNumberException_$ctor_Z721C83C5(message: string): NotFiniteNumberException {
+    return new NotFiniteNumberException(message);
+}
+
+export function NotFiniteNumberException_$ctor(): NotFiniteNumberException {
+    return NotFiniteNumberException_$ctor_Z721C83C5(SR_Arg_NotFiniteNumberException);
+}
+
+export class NotImplementedException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function NotImplementedException_$reflection(): TypeInfo {
+    return class_type("System.NotImplementedException", undefined, NotImplementedException, class_type("System.Exception"));
+}
+
+export function NotImplementedException_$ctor_Z721C83C5(message: string): NotImplementedException {
+    return new NotImplementedException(message);
+}
+
+export function NotImplementedException_$ctor(): NotImplementedException {
+    return NotImplementedException_$ctor_Z721C83C5(SR_Arg_NotImplementedException);
+}
+
+export class NotSupportedException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function NotSupportedException_$reflection(): TypeInfo {
+    return class_type("System.NotSupportedException", undefined, NotSupportedException, class_type("System.Exception"));
+}
+
+export function NotSupportedException_$ctor_Z721C83C5(message: string): NotSupportedException {
+    return new NotSupportedException(message);
+}
+
+export function NotSupportedException_$ctor(): NotSupportedException {
+    return NotSupportedException_$ctor_Z721C83C5(SR_Arg_NotSupportedException);
+}
+
+export class NullReferenceException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function NullReferenceException_$reflection(): TypeInfo {
+    return class_type("System.NullReferenceException", undefined, NullReferenceException, class_type("System.Exception"));
+}
+
+export function NullReferenceException_$ctor_Z721C83C5(message: string): NullReferenceException {
+    return new NullReferenceException(message);
+}
+
+export function NullReferenceException_$ctor(): NullReferenceException {
+    return NullReferenceException_$ctor_Z721C83C5(SR_Arg_NullReferenceException);
+}
+
+export class OutOfMemoryException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function OutOfMemoryException_$reflection(): TypeInfo {
+    return class_type("System.OutOfMemoryException", undefined, OutOfMemoryException, class_type("System.Exception"));
+}
+
+export function OutOfMemoryException_$ctor_Z721C83C5(message: string): OutOfMemoryException {
+    return new OutOfMemoryException(message);
+}
+
+export function OutOfMemoryException_$ctor(): OutOfMemoryException {
+    return OutOfMemoryException_$ctor_Z721C83C5(SR_Arg_OutOfMemoryException);
+}
+
+export class OverflowException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function OverflowException_$reflection(): TypeInfo {
+    return class_type("System.OverflowException", undefined, OverflowException, class_type("System.Exception"));
+}
+
+export function OverflowException_$ctor_Z721C83C5(message: string): OverflowException {
+    return new OverflowException(message);
+}
+
+export function OverflowException_$ctor(): OverflowException {
+    return OverflowException_$ctor_Z721C83C5(SR_Arg_OverflowException);
+}
+
+export class RankException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function RankException_$reflection(): TypeInfo {
+    return class_type("System.RankException", undefined, RankException, class_type("System.Exception"));
+}
+
+export function RankException_$ctor_Z721C83C5(message: string): RankException {
+    return new RankException(message);
+}
+
+export function RankException_$ctor(): RankException {
+    return RankException_$ctor_Z721C83C5(SR_Arg_RankException);
+}
+
+export class StackOverflowException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function StackOverflowException_$reflection(): TypeInfo {
+    return class_type("System.StackOverflowException", undefined, StackOverflowException, class_type("System.Exception"));
+}
+
+export function StackOverflowException_$ctor_Z721C83C5(message: string): StackOverflowException {
+    return new StackOverflowException(message);
+}
+
+export function StackOverflowException_$ctor(): StackOverflowException {
+    return StackOverflowException_$ctor_Z721C83C5(SR_Arg_StackOverflowException);
+}
+
+export class TimeoutException extends Exception {
+    constructor(message: string) {
+        super(message);
+    }
+}
+
+export function TimeoutException_$reflection(): TypeInfo {
+    return class_type("System.TimeoutException", undefined, TimeoutException, class_type("System.Exception"));
+}
+
+export function TimeoutException_$ctor_Z721C83C5(message: string): TimeoutException {
+    return new TimeoutException(message);
+}
+
+export function TimeoutException_$ctor(): TimeoutException {
+    return TimeoutException_$ctor_Z721C83C5(SR_Arg_TimeoutException);
+}
+
+export class ArgumentException extends Exception {
+    readonly paramName: string;
+    constructor(message: string, paramName: string) {
+        super(isNullOrEmpty(paramName) ? message : (((message + SR_Arg_ParamName_Name) + paramName) + "\')"));
+        this.paramName = paramName;
+    }
+}
+
+export function ArgumentException_$reflection(): TypeInfo {
+    return class_type("System.ArgumentException", undefined, ArgumentException, class_type("System.Exception"));
+}
+
+export function ArgumentException_$ctor_Z384F8060(message: string, paramName: string): ArgumentException {
+    return new ArgumentException(message, paramName);
+}
+
+export function ArgumentException_$ctor(): ArgumentException {
+    return ArgumentException_$ctor_Z384F8060(SR_Arg_ArgumentException, "");
+}
+
+export function ArgumentException_$ctor_Z721C83C5(message: string): ArgumentException {
+    return ArgumentException_$ctor_Z384F8060(message, "");
+}
+
+export function ArgumentException__get_ParamName(_: ArgumentException): string {
+    return _.paramName;
+}
+
+export class ArgumentNullException extends ArgumentException {
+    constructor(paramName: string, message: string) {
+        super(message, paramName);
+    }
+}
+
+export function ArgumentNullException_$reflection(): TypeInfo {
+    return class_type("System.ArgumentNullException", undefined, ArgumentNullException, ArgumentException_$reflection());
+}
+
+export function ArgumentNullException_$ctor_Z384F8060(paramName: string, message: string): ArgumentNullException {
+    return new ArgumentNullException(paramName, message);
+}
+
+export function ArgumentNullException_$ctor_Z721C83C5(paramName: string): ArgumentNullException {
+    return ArgumentNullException_$ctor_Z384F8060(paramName, SR_ArgumentNull_Generic);
+}
+
+export function ArgumentNullException_$ctor(): ArgumentNullException {
+    return ArgumentNullException_$ctor_Z721C83C5("");
+}
+
+export class ArgumentOutOfRangeException extends ArgumentException {
+    constructor(paramName: string, message: string) {
+        super(message, paramName);
+    }
+}
+
+export function ArgumentOutOfRangeException_$reflection(): TypeInfo {
+    return class_type("System.ArgumentOutOfRangeException", undefined, ArgumentOutOfRangeException, ArgumentException_$reflection());
+}
+
+export function ArgumentOutOfRangeException_$ctor_Z384F8060(paramName: string, message: string): ArgumentOutOfRangeException {
+    return new ArgumentOutOfRangeException(paramName, message);
+}
+
+export function ArgumentOutOfRangeException_$ctor_Z721C83C5(paramName: string): ArgumentOutOfRangeException {
+    return ArgumentOutOfRangeException_$ctor_Z384F8060(paramName, SR_Arg_ArgumentOutOfRangeException);
+}
+
+export function ArgumentOutOfRangeException_$ctor(): ArgumentOutOfRangeException {
+    return ArgumentOutOfRangeException_$ctor_Z721C83C5("");
+}
+

package/TimeOnly.ts

@@ -1,14 +1,14 @@
-import { FSharpRef } from "./Types.js";
-import { hours, minutes, seconds, milliseconds } from "./TimeSpan.js";
-import { DateKind, IDateTime, padWithZeros } from "./Util.js";
+import { FSharpRef } from "./Types.ts";
+import { hours, minutes, seconds, milliseconds } from "./TimeSpan.ts";
+import { Exception, DateTimeKind, IDateTime, padWithZeros } from "./Util.ts";
 
 const millisecondsPerDay = 86400000;
 
 export function create(h: number = 0, m: number = 0, s: number = 0, ms: number = 0) {
   if (h < 0 || m < 0 || s < 0 || ms < 0)
-    throw new Error("The parameters describe an unrepresentable TimeOnly.");
+    throw new Exception("The parameters describe an unrepresentable TimeOnly.");
 
-  return h * 3600000 + m * 60000 + s * 1000 + ms;
+  return h * 3600000 + m * 60_000 + s * 1000 + ms;
 }
 
 export function fromTicks(ticks: number | bigint) {
@@ -17,13 +17,13 @@ export function fromTicks(ticks: number | bigint) {
 
 export function fromTimeSpan(timeSpan: number) {
   if (timeSpan < 0 || timeSpan >= millisecondsPerDay)
-    throw new Error("The TimeSpan describes an unrepresentable TimeOnly.");
+    throw new Exception("The TimeSpan describes an unrepresentable TimeOnly.");
 
   return timeSpan;
 }
 
 export function fromDateTime(d: IDateTime) {
-  return d.kind === DateKind.UTC
+  return d.kind === DateTimeKind.Utc
     ? create(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())
     : create(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
 }
@@ -61,7 +61,7 @@ export function addHours(t: number, h: number) {
 }
 
 export function addMinutes(t: number, m: number) {
-  return add(t, m * 60000);
+  return add(t, m * 60_000);
 }
 
 export function isBetween(t: number, start: number, end: number) {
@@ -72,7 +72,7 @@ export function isBetween(t: number, start: number, end: number) {
 
 export function toString(t: number, format = "t", _provider?: any) {
   if (["r", "R", "o", "O", "t", "T"].indexOf(format) === -1) {
-    throw new Error("Custom formats are not supported");
+    throw new Exception("Custom formats are not supported");
   }
 
   const base = `${padWithZeros(hours(t), 2)}:${padWithZeros(minutes(t), 2)}`
@@ -114,7 +114,7 @@ export function parse(str: string) {
     return create(h, m, s, Math.trunc(ms));
   }
 
-  throw new Error(`String '${str}' was not recognized as a valid TimeOnly.`);
+  throw new Exception(`String '${str}' was not recognized as a valid TimeOnly.`);
 }
 
 export function tryParse(v: string, defValue: FSharpRef<number>): boolean {

package/TimeSpan.ts

@@ -1,6 +1,6 @@
-import { FSharpRef } from "./Types.js";
-import { comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.js";
-import { toInt64, fromFloat64 } from "./BigInt.js";
+import { FSharpRef } from "./Types.ts";
+import { Exception, comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.ts";
+import { toInt64, fromFloat64 } from "./BigInt.ts";
 
 // TimeSpan in runtime just becomes a number representing milliseconds
 export type TimeSpan = number;
@@ -28,7 +28,7 @@ export function create(d: number = 0, h: number = 0, m: number = 0, s: number =
       // d,h,m,s,ms
       break;
   }
-  return d * 86400000 + h * 3600000 + m * 60000 + s * 1000 + ms;
+  return d * 86400000 + h * 3600000 + m * 60_000 + s * 1000 + ms;
 }
 
 export function fromTicks(ticks: number | bigint) {
@@ -64,11 +64,11 @@ export function hours(ts: TimeSpan) {
 }
 
 export function minutes(ts: TimeSpan) {
-  return signedRound(ts % 3600000 / 60000);
+  return signedRound(ts % 3600000 / 60_000);
 }
 
 export function seconds(ts: TimeSpan) {
-  return signedRound(ts % 60000 / 1000);
+  return signedRound(ts % 60_000 / 1000);
 }
 
 export function milliseconds(ts: TimeSpan) {
@@ -88,7 +88,7 @@ export function totalHours(ts: TimeSpan) {
 }
 
 export function totalMinutes(ts: TimeSpan) {
-  return ts / 60000;
+  return ts / 60_000;
 }
 
 export function totalSeconds(ts: TimeSpan) {
@@ -129,7 +129,7 @@ export function duration(x: number) {
 
 export function toString(ts: TimeSpan, format = "c", _provider?: any) {
   if (["c", "g", "G"].indexOf(format) === -1) {
-    throw new Error("Custom formats are not supported");
+    throw new Exception("Custom formats are not supported");
   }
   const d = Math.abs(days(ts));
   const h = Math.abs(hours(ts));
@@ -146,7 +146,7 @@ export function parse(str: string) {
   if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4
     const d = parseInt(str, 0);
     if (isNaN(d)) {
-      throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+      throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
     } else {
       return create(d, 0, 0, 0, 0);
     }
@@ -178,13 +178,13 @@ export function parse(str: string) {
           case 6: ms = +r[8] / 1000; break;
           case 7: ms = +r[8] / 10000; break;
           default:
-            throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+            throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
         }
       }
       return sign * create(d, h, m, s, ms);
     }
   }
-  throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);
+  throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
 }
 
 export function tryParse(v: string, defValue: FSharpRef<number>): boolean {

package/Timer.ts

@@ -1,5 +1,5 @@
-import { Event } from "./Event.js";
-import { IDisposable } from "./Util.js";
+import { Event } from "./Event.ts";
+import { IDisposable } from "./Util.ts";
 
 export class Timer implements IDisposable {
   public Interval: number;

package/Types.ts

@@ -1,4 +1,4 @@
-import { IComparable, IEquatable, IHashable, combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from "./Util.js";
+import { Exception, IComparable, IEquatable, IHashable, combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from "./Util.ts";
 
 // This type is only used internally for .ts files in the library
 // F# Result type is in Choice.fs
@@ -186,24 +186,6 @@ export class FSharpRef<T> {
 
 // EXCEPTIONS
 
-// Exception is intentionally not derived from Error, for performance reasons (see #2160)
-export class Exception {
-  constructor(public message?: string) { }
-}
-
-export function isException(x: any) {
-  return x instanceof Exception || x instanceof Error;
-}
-
-export function isPromise(x: any) {
-  return x instanceof Promise;
-}
-
-export function ensureErrorOrException(e: any): any {
-  // Exceptionally admitting promises as errors for compatibility with React.suspense (see #3298)
-  return (isException(e) || isPromise(e)) ? e : new Error(String(e));
-}
-
 export abstract class FSharpException extends Exception
   implements IEquatable<FSharpException>, IComparable<FSharpException> {
   toJSON() { return recordToJSON(this); }

package/Uri.ts

@@ -1,14 +1,17 @@
-import { FSharpRef, Result } from "./Types.js";
+import { FSharpRef, Result } from "./Types.ts";
+import { Exception } from "./Util.ts";
 
-export const enum UriKind {
-  RelativeOrAbsolute = 0,
-  Absolute = 1,
-  Relative = 2,
-}
+export const UriKind = {
+  RelativeOrAbsolute: 0,
+  Absolute: 1,
+  Relative: 2,
+} as const;
+
+export type UriKind = typeof UriKind[keyof typeof UriKind];
 
 type State =
-  | { original: string; value: URL; kind: UriKind.Absolute }
-  | { original: string; value: string; kind: UriKind.Relative };
+  | { original: string; value: URL; kind: typeof UriKind.Absolute }
+  | { original: string; value: string; kind: typeof UriKind.Relative };
 
 const ok = <T>(value: T): Result<T> => ({
   tag: "ok",
@@ -104,7 +107,7 @@ export class Uri {
       case "ok":
         return result.value;
       case "error":
-        throw new Error(result.error);
+        throw new Exception(result.error);
       default:
         const never: never = result;
         return never;
@@ -156,7 +159,7 @@ export class Uri {
       case UriKind.Absolute:
         return this.uri.value;
       case UriKind.Relative:
-        throw new Error("This operation is not supported for a relative URI.");
+        throw new Exception("This operation is not supported for a relative URI.");
       default:
         const never: never = this.uri;
         return never;