@fable-org/fable-library-js 2.4.1 → 2.5.0

package/Async.js

@@ -7,10 +7,6 @@ import { Exception } from "./Util.js";
 function emptyContinuation(_x) {
     // NOP
 }
-// see AsyncBuilder.Delay
-function delay(generator) {
-    return protectedCont((ctx) => generator()(ctx));
-}
 // MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>
 export function makeAsync(body) {
     return body;
@@ -49,18 +45,27 @@ export function throwIfCancellationRequested(token) {
     }
 }
 export function startChild(computation, ms) {
-    const promise = startAsPromise(computation);
-    let promiseToRun = promise;
-    if (ms) {
-        // Race the computation against a timeout: whichever settles first wins.
-        promiseToRun = new Promise((resolve, reject) => {
-            const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
-            promise.then(value => { clearTimeout(timeoutId); resolve(value); }, error => { clearTimeout(timeoutId); reject(error); });
-        });
-    }
-    // JS Promises are hot, computation has already started
-    // but we delay returning the result
-    return protectedCont((ctx) => protectedReturn(awaitPromise(promiseToRun))(ctx));
+    return protectedCont((ctx) => {
+        // Share the parent's cancellation token so cancelling the parent
+        // cancels the child, like .NET Async.StartChild
+        const promise = startAsPromise(computation, ctx.cancelToken);
+        let promiseToRun = promise;
+        if (ms) {
+            // Race the computation against a timeout: whichever settles first wins.
+            promiseToRun = new Promise((resolve, reject) => {
+                const timeoutId = setTimeout(() => reject(TimeoutException_$ctor()), ms);
+                promise.then(value => { clearTimeout(timeoutId); resolve(value); }, error => { clearTimeout(timeoutId); reject(error); });
+            });
+        }
+        // Prevent an unhandled rejection when the child is cancelled or fails
+        // while nobody awaits it (in F# an unobserved child's cancellation or
+        // failure is simply not propagated). awaitPromise attaches its own
+        // handlers to the same promise, so awaiting still observes the result.
+        promiseToRun.catch(emptyContinuation);
+        // JS Promises are hot, computation has already started
+        // but we delay returning the result
+        protectedReturn(awaitPromise(promiseToRun))(ctx);
+    });
 }
 export function awaitPromise(p) {
     return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledException
@@ -106,17 +111,19 @@ export function ignore(computation) {
     return protectedBind(computation, (_x) => protectedReturn(void 0));
 }
 export function parallel(computations) {
-    return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
+    // Children share the parent's cancellation token, like .NET Async.Parallel
+    return protectedCont((ctx) => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w, ctx.cancelToken))))(ctx));
 }
 export function sequential(computations) {
-    function _sequential(computations) {
+    function _sequential(computations, cancelToken) {
         let pr = Promise.resolve([]);
         for (const c of computations) {
-            pr = pr.then(results => startAsPromise(c).then(r => results.concat([r])));
+            pr = pr.then(results => startAsPromise(c, cancelToken).then(r => results.concat([r])));
         }
         return pr;
     }
-    return delay(() => awaitPromise(_sequential(computations)));
+    // Children share the parent's cancellation token, like .NET Async.Sequential
+    return protectedCont((ctx) => awaitPromise(_sequential(computations, ctx.cancelToken))(ctx));
 }
 export function sleep(millisecondsDueTime) {
     return protectedCont((ctx) => {
@@ -139,10 +146,14 @@ export function startImmediate(computation, cancellationToken) {
 }
 export function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {
     const trampoline = new Trampoline();
+    // Mark the computation completed as soon as a terminal continuation is entered
+    // so protectedCont lets exceptions from continuation code propagate instead of
+    // routing them to onError (see Trampoline.completed).
+    const done = (cont) => (x) => { trampoline.completed = true; return cont(x); };
     computation({
-        onSuccess: continuation ? continuation : emptyContinuation,
-        onError: exceptionContinuation,
-        onCancel: cancellationContinuation,
+        onSuccess: done(continuation ? continuation : emptyContinuation),
+        onError: done(exceptionContinuation),
+        onCancel: done(cancellationContinuation),
         cancelToken: cancelToken ? cancelToken : defaultCancellationToken,
         trampoline,
     });

package/AsyncBuilder.js

@@ -47,6 +47,7 @@ export class Trampoline {
     }
     constructor() {
         this.callCount = 0;
+        this.completed = false;
     }
     incrementAndCheck() {
         return this.callCount++ > Trampoline.maxTrampolineCallCount;
@@ -67,6 +68,9 @@ export function protectedCont(f) {
                     f(ctx);
                 }
                 catch (err) {
+                    if (ctx.trampoline.completed) {
+                        throw err;
+                    }
                     ctx.onError(ensureErrorOrException(err));
                 }
             });
@@ -76,6 +80,13 @@ export function protectedCont(f) {
                 f(ctx);
             }
             catch (err) {
+                // Once a terminal continuation has run the computation is complete, so
+                // an exception from user continuation code must propagate rather than be
+                // routed to onError (which would resolve the computation a second time,
+                // e.g. a succeeded try/with body re-entering its with handler).
+                if (ctx.trampoline.completed) {
+                    throw err;
+                }
                 ctx.onError(ensureErrorOrException(err));
             }
         }
@@ -85,12 +96,18 @@ export function protectedBind(computation, binder) {
     return protectedCont((ctx) => {
         computation({
             onSuccess: (x) => {
+                // Only guard the binder evaluation itself: the resulting computation
+                // is protected on its own, and re-catching what it throws would
+                // route continuation exceptions back into onError (double-resolve).
+                let bound;
                 try {
-                    binder(x)(ctx);
+                    bound = binder(x);
                 }
                 catch (err) {
                     ctx.onError(ensureErrorOrException(err));
+                    return;
                 }
+                bound(ctx);
             },
             onError: ctx.onError,
             onCancel: ctx.onCancel,
@@ -155,12 +172,16 @@ export class AsyncBuilder {
                 cancelToken: ctx.cancelToken,
                 trampoline: ctx.trampoline,
                 onError: (ex) => {
+                    // See protectedBind: only guard the handler evaluation itself.
+                    let handled;
                     try {
-                        catchHandler(ex)(ctx);
+                        handled = catchHandler(ex);
                     }
                     catch (err) {
                         ctx.onError(ensureErrorOrException(err));
+                        return;
                     }
+                    handled(ctx);
                 },
             });
         });

package/BitConverter.js

@@ -77,7 +77,7 @@ export function doubleToInt64Bits(value) {
 export function toBoolean(bytes, offset) {
     const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
     const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
-    return view.getUint8(offset) === 1 ? true : false;
+    return view.getUint8(offset) !== 0;
 }
 export function toChar(bytes, offset) {
     const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
@@ -134,5 +134,5 @@ export function toString(bytes, offset, count) {
     else if (offset != null) {
         buffer = buffer.subarray(offset);
     }
-    return Array.from(buffer).map((b) => ("0" + b.toString(16)).slice(-2)).join("-");
+    return Array.from(buffer).map((b) => ("0" + b.toString(16)).slice(-2).toUpperCase()).join("-");
 }

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: d6ae6bd3790b57b31941a118cdffaeb6a59155c3
+last_commit_released: 6568f35ece227fc30ce84111c8d2e975b09bac00
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,25 @@ 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).
 
+## 2.5.0 - 2026-07-15
+
+### 🚀 Features
+
+* *(js/ts)* Add `System.IO.Directory` support (Exists, CreateDirectory) (#4798) ([6568f35e](https://github.com/fable-compiler/Fable/commit/6568f35ece227fc30ce84111c8d2e975b09bac00))
+* *(js/ts/python/beam)* Preserve member calls and pattern matches in quotations (#4780) ([55482e6b](https://github.com/fable-compiler/Fable/commit/55482e6b5e6306fd4dbaba5759024313cb26682a))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/a8d9bf5f0b7cc4560bb107963348e765695c22b6..6568f35ece227fc30ce84111c8d2e975b09bac00)</small></strong>
+
+## 2.4.2 - 2026-07-11
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* Async cancellation propagation and continuation double-resolve (#4746) ([c78a9a8e](https://github.com/fable-compiler/Fable/commit/c78a9a8ed20234feddf3375b61e91098f9261bee))
+* *(js/ts)* Date arithmetic: PM parsing, AddMonths day clamp, AddYears offset (#4744) ([be0558eb](https://github.com/fable-compiler/Fable/commit/be0558ebe07f78f7a93ec0c34592d7c066b59fc7))
+* *(js/ts)* Int64 non-decimal parsing and BitConverter .NET mismatches (#4748) ([2704d9c5](https://github.com/fable-compiler/Fable/commit/2704d9c5daab87eb1791c0ea1b6b8b06b987247c))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/d6ae6bd3790b57b31941a118cdffaeb6a59155c3..a8d9bf5f0b7cc4560bb107963348e765695c22b6)</small></strong>
+
 ## 2.4.1 - 2026-07-09
 
 ### 🐞 Bug Fixes

package/Date.js

@@ -595,7 +595,10 @@ export function parseRaw(input) {
                         parseInt(timeParts[1] || "0", 10) * 60 +
                         parseFloat(timeParts[2] || "0");
                 if (m[3] != null && m[3].toUpperCase() === "PM" && hourPart < 12) {
-                    timeInSeconds += 720;
+                    timeInSeconds += 12 * 3600;
+                }
+                else if (m[3] != null && m[3].toUpperCase() === "AM" && hourPart === 12) {
+                    timeInSeconds -= 12 * 3600;
                 }
             }
             if (m[4] != null) { // There's an offset, parse as UTC
@@ -784,19 +787,9 @@ export function addYears(d, v) {
     return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);
 }
 export function addMonths(d, v) {
-    let newMonth = month(d) + v;
-    let newMonth_ = 0;
-    let yearOffset = 0;
-    if (newMonth > 12) {
-        newMonth_ = newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12);
-        newMonth = newMonth_;
-    }
-    else if (newMonth < 1) {
-        newMonth_ = 12 + newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
-        newMonth = newMonth_;
-    }
+    const totalMonths = month(d) + v;
+    const newMonth = ((totalMonths - 1) % 12 + 12) % 12 + 1;
+    const yearOffset = Math.floor((totalMonths - 1) / 12);
     const newYear = year(d) + yearOffset;
     const _daysInMonth = daysInMonth(newYear, newMonth);
     const newDay = Math.min(_daysInMonth, day(d));

package/DateOffset.js

@@ -203,27 +203,18 @@ export function addTicks(d, v) {
     return add(d, toFloat64(v / 10000n));
 }
 export function addYears(d, v) {
-    const newMonth = d.getUTCMonth() + 1;
-    const newYear = d.getUTCFullYear() + v;
+    const d2 = new Date(d.getTime() + offset(d));
+    const newMonth = d2.getUTCMonth() + 1;
+    const newYear = d2.getUTCFullYear() + v;
     const _daysInMonth = daysInMonth(newYear, newMonth);
-    const newDay = Math.min(_daysInMonth, d.getUTCDate());
-    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), offset(d));
+    const newDay = Math.min(_daysInMonth, d2.getUTCDate());
+    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), offset(d));
 }
 export function addMonths(d, v) {
     const d2 = new Date(d.getTime() + offset(d));
-    let newMonth = d2.getUTCMonth() + 1 + v;
-    let newMonth_ = 0;
-    let yearOffset = 0;
-    if (newMonth > 12) {
-        newMonth_ = newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12);
-        newMonth = newMonth_;
-    }
-    else if (newMonth < 1) {
-        newMonth_ = 12 + newMonth % 12;
-        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);
-        newMonth = newMonth_;
-    }
+    const totalMonths = d2.getUTCMonth() + 1 + v;
+    const newMonth = ((totalMonths - 1) % 12 + 12) % 12 + 1;
+    const yearOffset = Math.floor((totalMonths - 1) / 12);
     const newYear = d2.getUTCFullYear() + yearOffset;
     const _daysInMonth = daysInMonth(newYear, newMonth);
     const newDay = Math.min(_daysInMonth, d2.getUTCDate());

package/Directory.js

@@ -0,0 +1,11 @@
+// This library doesn't depend on @types/node (to stay browser-compatible),
+// so this Node.js built-in import can't be type-checked; the exported
+// functions below still declare their own types for callers to rely on.
+// @ts-ignore
+import { existsSync, mkdirSync, statSync } from "node:fs";
+export function exists(path) {
+    return existsSync(path) && statSync(path).isDirectory();
+}
+export function createDirectory(path) {
+    mkdirSync(path, { recursive: true });
+}

package/Long.js

@@ -1,37 +1,28 @@
 import { getPrefix, isValid } from "./Int32.js";
 import { fromString } from "./BigInt.js";
 import { Exception } from "./Util.js";
-function getMaxValue(unsigned, radix, isNegative) {
-    switch (radix) {
-        case 2: return unsigned ?
-            "1111111111111111111111111111111111111111111111111111111111111111" :
-            (isNegative ? "1000000000000000000000000000000000000000000000000000000000000000"
-                : "111111111111111111111111111111111111111111111111111111111111111");
-        case 8: return unsigned ?
-            "1777777777777777777777" :
-            (isNegative ? "1000000000000000000000" : "777777777777777777777");
-        case 10: return unsigned ?
-            "18446744073709551615" :
-            (isNegative ? "9223372036854775808" : "9223372036854775807");
-        case 16: return unsigned ?
-            "FFFFFFFFFFFFFFFF" :
-            (isNegative ? "8000000000000000" : "7FFFFFFFFFFFFFFF");
-        default: throw new Exception("Invalid radix.");
+function getRange(unsigned, bitsize) {
+    switch (bitsize) {
+        case 64: return unsigned ?
+            [0n, 18446744073709551615n] :
+            [-9223372036854775808n, 9223372036854775807n];
+        default: throw new Exception("Invalid bit size.");
     }
 }
-export function parse(str, style, unsigned, _bitsize, radix) {
+export function parse(str, style, unsigned, bitsize, radix) {
     const res = isValid(str, style, radix);
     if (res != null) {
-        const lessOrEqual = (x, y) => {
-            const len = Math.max(x.length, y.length);
-            return x.padStart(len, "0") <= y.padStart(len, "0");
-        };
-        const isNegative = res.sign === "-";
-        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);
-        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {
-            str = getPrefix(res.radix) + res.digits;
-            str = isNegative ? res.sign + str : str;
-            return fromString(str);
+        let v = fromString(getPrefix(res.radix) + res.digits);
+        if (res.sign === "-") {
+            v = -v;
+        }
+        const [umin, umax] = getRange(true, bitsize);
+        if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {
+            v = BigInt.asIntN(bitsize, v);
+        }
+        const [min, max] = getRange(unsigned, bitsize);
+        if (v >= min && v <= max) {
+            return v;
         }
     }
     throw new Exception(`The input string ${str} was not in a correct format.`);

package/package.json

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

package/quotation.js

@@ -5,6 +5,7 @@
  * and pattern matching helpers compatible with Fable's option convention
  * (undefined = no match, value/tuple = match).
  */
+import { ofArray } from "./List.js";
 // ===================================================================
 // Var: represents an F# quotation variable
 // ===================================================================
@@ -74,11 +75,12 @@ export class ExprIfThenElse {
     toJSON() { return ["IfThenElse", this.guard, this.thenExpr, this.elseExpr]; }
 }
 export class ExprCall {
-    constructor(instance, method, args) {
+    constructor(instance, method, args, declaringType = "") {
         this.tag = "Call";
         this.instance = instance;
         this.method = method;
         this.args = args;
+        this.declaringType = declaringType;
     }
     toJSON() { return ["Call", this.instance, this.method, this.args]; }
 }
@@ -176,6 +178,10 @@ export class ExprVarSet {
 export function mkValue(value, type) {
     return new ExprValue(value, type);
 }
+export function mkNull(type) {
+    // A null-value node (no instance / null literal / empty option or list).
+    return new ExprValue(null, type);
+}
 export function mkVar(v) {
     return new ExprVarExpr(v);
 }
@@ -191,8 +197,8 @@ export function mkLet(v, value, body) {
 export function mkIfThenElse(guard, thenExpr, elseExpr) {
     return new ExprIfThenElse(guard, thenExpr, elseExpr);
 }
-export function mkCall(instance, method, args) {
-    return new ExprCall(instance, method, args);
+export function mkCall(instance, method, args, declaringType = "") {
+    return new ExprCall(instance, method, args, declaringType);
 }
 export function mkSequential(first, second) {
     return new ExprSequential(first, second);
@@ -273,10 +279,17 @@ export function isIfThenElse(expr) {
     return undefined;
 }
 export function isCall(expr) {
-    if (expr instanceof ExprCall)
-        return [expr.instance, expr.method, expr.args];
+    if (expr instanceof ExprCall) {
+        // "novalue" is the "no instance" sentinel, distinct from a genuine quoted null ("null").
+        const instance = (expr.instance instanceof ExprValue && expr.instance.type === "novalue") ? null : expr.instance;
+        // Must be a real FSharpList (not the raw array), same reasoning as isFieldGet below.
+        return [instance, expr.method, ofArray(expr.args)];
+    }
     return undefined;
 }
+export function callDeclaringType(expr) {
+    return expr instanceof ExprCall ? expr.declaringType : "";
+}
 export function isSequential(expr) {
     if (expr instanceof ExprSequential)
         return [expr.first, expr.second];
@@ -303,8 +316,12 @@ export function isTupleGet(expr) {
     return undefined;
 }
 export function isFieldGet(expr) {
-    if (expr instanceof ExprFieldGet)
-        return [expr.expr, expr.fieldName];
+    // Third element mirrors PropertyGet's indexer-args slot, always empty here (never indexed).
+    // "novalue" is the "no instance" sentinel, distinct from a genuine quoted null ("null").
+    if (expr instanceof ExprFieldGet) {
+        const instance = (expr.expr instanceof ExprValue && expr.expr.type === "novalue") ? null : expr.expr;
+        return [instance, expr.fieldName, []];
+    }
     return undefined;
 }
 // ===================================================================
@@ -555,7 +572,7 @@ export function substitute(expr, fn) {
             return new ExprIfThenElse(sub(e.guard), sub(e.thenExpr), sub(e.elseExpr));
         if (e instanceof ExprCall) {
             const newInst = e.instance != null ? sub(e.instance) : e.instance;
-            return new ExprCall(newInst, e.method, e.args.map(sub));
+            return new ExprCall(newInst, e.method, e.args.map(sub), e.declaringType);
         }
         if (e instanceof ExprSequential)
             return new ExprSequential(sub(e.first), sub(e.second));