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

package/Async.ts

@@ -1,9 +1,10 @@
-import { OperationCanceledError, Trampoline } from "./AsyncBuilder.js";
-import { Continuation, Continuations } from "./AsyncBuilder.js";
-import { Async, IAsyncContext, CancellationToken } from "./AsyncBuilder.js";
-import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.js";
-import { FSharpChoice$2_$union, Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.js";
-import { TimeoutException } from "./SystemException.js";
+import { OperationCanceledException, Trampoline } from "./AsyncBuilder.ts";
+import { Continuation, Continuations } from "./AsyncBuilder.ts";
+import { Async, IAsyncContext, CancellationToken } from "./AsyncBuilder.ts";
+import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.ts";
+import { FSharpChoice$2_$union, Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.ts";
+import { TimeoutException_$ctor } from "./System.ts";
+import { Exception } from "./Util.ts";
 
 function emptyContinuation<T>(_x: T) {
   // NOP
@@ -53,7 +54,7 @@ export function isCancellationRequested(token: CancellationToken) {
 
 export function throwIfCancellationRequested(token: CancellationToken) {
   if (token != null && token.isCancelled) {
-    throw new Error("Operation is cancelled");
+    throw new Exception("Operation is cancelled");
   }
 }
 
@@ -62,11 +63,11 @@ function throwAfter(millisecondsDueTime: number): Async<void> {
     let tokenId: number;
     const timeoutId = setTimeout(() => {
       ctx.cancelToken.removeListener(tokenId);
-      ctx.onError(new TimeoutException() as Error);
+      ctx.onError(TimeoutException_$ctor());
     }, millisecondsDueTime);
     tokenId = ctx.cancelToken.addListener(() => {
       clearTimeout(timeoutId);
-      ctx.onCancel(new OperationCanceledError());
+      ctx.onCancel(new OperationCanceledException());
     });
   });
 }
@@ -93,7 +94,7 @@ export function startChild<T>(computation: Async<T>, ms?: number): Async<Async<T
 export function awaitPromise<T>(p: Promise<T>) {
   return fromContinuations((conts: Continuations<T>) =>
     p.then(conts[0]).catch((err) =>
-      (err instanceof OperationCanceledError
+      (err instanceof OperationCanceledException
         ? conts[2] : conts[1])(err)));
 }
 
@@ -104,7 +105,7 @@ export function cancellationToken() {
 export const defaultCancellationToken = new CancellationToken();
 
 export function catchAsync<T>(work: Async<T>) {
-  return protectedCont((ctx: IAsyncContext<FSharpChoice$2_$union<T, Error>>) => {
+  return protectedCont((ctx: IAsyncContext<FSharpChoice$2_$union<T, Exception>>) => {
     work({
       onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),
       onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),
@@ -154,7 +155,7 @@ export function sleep(millisecondsDueTime: number) {
     }, millisecondsDueTime);
     tokenId = ctx.cancelToken.addListener(() => {
       clearTimeout(timeoutId);
-      ctx.onCancel(new OperationCanceledError());
+      ctx.onCancel(new OperationCanceledException());
     });
   });
 }

package/AsyncBuilder.ts

@@ -1,5 +1,4 @@
-import { ensureErrorOrException } from './Types.js';
-import { IDisposable } from "./Util.js";
+import { Exception, ensureErrorOrException, IDisposable } from "./Util.ts";
 
 export interface AsyncReplyChannel<Reply> {
   reply(value: Reply): void
@@ -9,8 +8,8 @@ export type Continuation<T> = (x: T) => void;
 
 export type Continuations<T> = [
   Continuation<T>,
-  Continuation<Error>,
-  Continuation<OperationCanceledError>
+  Continuation<Exception>,
+  Continuation<OperationCanceledException>
 ];
 
 export class CancellationToken implements IDisposable {
@@ -53,10 +52,10 @@ export class CancellationToken implements IDisposable {
   }
 }
 
-export class OperationCanceledError extends Error {
-  constructor() {
-    super("The operation was canceled");
-    Object.setPrototypeOf(this, OperationCanceledError.prototype);
+export class OperationCanceledException extends Exception {
+  constructor(msg?: string) {
+    super(msg ?? "The operation was canceled");
+    // Object.setPrototypeOf(this, OperationCanceledException.prototype);
   }
 }
 
@@ -79,8 +78,8 @@ export class Trampoline {
 
 export interface IAsyncContext<T> {
   onSuccess: Continuation<T>;
-  onError: Continuation<Error>;
-  onCancel: Continuation<OperationCanceledError>;
+  onError: Continuation<Exception>;
+  onCancel: Continuation<OperationCanceledException>;
 
   cancelToken: CancellationToken;
   trampoline: Trampoline;
@@ -91,7 +90,7 @@ export type Async<T> = (x: IAsyncContext<T>) => void;
 export function protectedCont<T>(f: Async<T>) {
   return (ctx: IAsyncContext<T>) => {
     if (ctx.cancelToken.isCancelled) {
-      ctx.onCancel(new OperationCanceledError());
+      ctx.onCancel(new OperationCanceledException());
     } else if (ctx.trampoline.incrementAndCheck()) {
       ctx.trampoline.hijack(() => {
         try {

package/BigInt.ts

@@ -1,7 +1,7 @@
-import { FSharpRef } from "./Types.js";
-import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.js";
-import { decimal, fromParts, truncate } from "./Decimal.js";
-import { bigintHash } from "./Util.js";
+import { FSharpRef } from "./Types.ts";
+import { int8, uint8, int16, uint16, int32, uint32, float16, float32, float64 } from "./Int32.ts";
+import { decimal, fromParts, truncate } from "./Decimal.ts";
+import { Exception, bigintHash } from "./Util.ts";
 
 const isBigEndian = false;
 
@@ -138,7 +138,7 @@ export function toIntN(bits: number, x: bigint, signed: boolean): bigint {
     let higher_bits = abs(x) >> BigInt(bits);
     if (higher_bits !== 0n) {
         const s = signed ? "a signed" : "an unsigned";
-        throw new Error(`Value was either too large or too small for ${s} ${bits}-bit integer.`);
+        throw new Exception(`Value was either too large or too small for ${s} ${bits}-bit integer.`);
     }
     return signed ? BigInt.asIntN(bits, x) : BigInt.asUintN(bits, x);
 }
@@ -338,7 +338,7 @@ function toSignedBytes(x: bigint, isBigEndian: boolean): Uint8Array {
 
 function fromSignedBytes(bytes: ArrayLike<uint8>, isBigEndian: boolean) {
     if (bytes == null) {
-        throw new Error("bytes is null");
+        throw new Exception("bytes is null");
     }
     const len = bytes.length;
     const first = isBigEndian ? 0 : len - 1;

package/BitConverter.ts

@@ -1,6 +1,6 @@
-import { uint8, int16, uint16, int32, uint32, float32, float64 } from "./Int32.js";
-import { int64, uint64 } from "./BigInt.js";
-import { char } from "./Char.js";
+import { uint8, int16, uint16, int32, uint32, float32, float64 } from "./Int32.ts";
+import { int64, uint64 } from "./BigInt.ts";
+import { char } from "./Char.ts";
 
 const littleEndian = true;
 

package/Boolean.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<boolean>): boolean {
   if (str != null && str.match(/^\s*true\s*$/i)) {
@@ -17,6 +18,6 @@ export function parse(str: string): boolean {
   if (tryParse(str, defValue)) {
     return defValue.contents;
   } else {
-    throw new Error(`String '${str}' was not recognized as a valid Boolean.`)
+    throw new Exception(`String '${str}' was not recognized as a valid Boolean.`)
   }
 }

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 2.0.0-beta.5 - 2025-11-19
+
+### Changed
+
+* [JS/TS] Replace the deprecated `substr` method with `slice` (by @Thorium)
+
+## 2.0.0-beta.4 - 2025-07-25
+
+### Added
+
+* [JS/TS] Initial support for Nullable Reference Types (by @ncave)
+
 ## 2.0.0-beta.3 - 2025-03-14
 
 ### Fixed

package/Char.ts

@@ -1,4 +1,5 @@
-import * as Unicode from "./Unicode.13.0.0.js";
+import * as Unicode from "./Unicode.13.0.0.ts";
+import { Exception } from "./Util.ts";
 
 export type char = string;
 
@@ -32,38 +33,40 @@ function getCategoryFunc() {
   };
 }
 
-export const enum UnicodeCategory {
-  UppercaseLetter,
-  LowercaseLetter,
-  TitlecaseLetter,
-  ModifierLetter,
-  OtherLetter,
-  NonSpacingMark,
-  SpacingCombiningMark,
-  EnclosingMark,
-  DecimalDigitNumber,
-  LetterNumber,
-  OtherNumber,
-  SpaceSeparator,
-  LineSeparator,
-  ParagraphSeparator,
-  Control,
-  Format,
-  Surrogate,
-  PrivateUse,
-  ConnectorPunctuation,
-  DashPunctuation,
-  OpenPunctuation,
-  ClosePunctuation,
-  InitialQuotePunctuation,
-  FinalQuotePunctuation,
-  OtherPunctuation,
-  MathSymbol,
-  CurrencySymbol,
-  ModifierSymbol,
-  OtherSymbol,
-  OtherNotAssigned,
-}
+export const UnicodeCategory = {
+  UppercaseLetter: 0,
+  LowercaseLetter: 1,
+  TitlecaseLetter: 2,
+  ModifierLetter: 3,
+  OtherLetter: 4,
+  NonSpacingMark: 5,
+  SpacingCombiningMark: 6,
+  EnclosingMark: 7,
+  DecimalDigitNumber: 8,
+  LetterNumber: 9,
+  OtherNumber: 10,
+  SpaceSeparator: 11,
+  LineSeparator: 12,
+  ParagraphSeparator: 13,
+  Control: 14,
+  Format: 15,
+  Surrogate: 16,
+  PrivateUse: 17,
+  ConnectorPunctuation: 18,
+  DashPunctuation: 19,
+  OpenPunctuation: 20,
+  ClosePunctuation: 21,
+  InitialQuotePunctuation: 22,
+  FinalQuotePunctuation: 23,
+  OtherPunctuation: 24,
+  MathSymbol: 25,
+  CurrencySymbol: 26,
+  ModifierSymbol: 27,
+  OtherSymbol: 28,
+  OtherNotAssigned: 29,
+} as const;
+
+export type UnicodeCategory = typeof UnicodeCategory[keyof typeof UnicodeCategory];
 
 const isControlMask = 1 << UnicodeCategory.Control;
 const isDigitMask = 1 << UnicodeCategory.DecimalDigitNumber;
@@ -108,7 +111,7 @@ function charCodeAt(s: string, index: number) {
   if (index >= 0 && index < s.length) {
     return s.charCodeAt(index);
   } else {
-    throw new Error("Index out of range.");
+    throw new Exception("Index out of range.");
   }
 }
 
@@ -217,6 +220,6 @@ export function parse(input: string) {
   if (input.length === 1) {
     return input[0];
   } else {
-    throw new Error("String must be exactly one character long.");
+    throw new Exception("String must be exactly one character long.");
   }
 }