@fable-org/fable-library-js 2.0.0-rc.5 → 2.0.0

package/Array.js

@@ -3,8 +3,9 @@ import { Helpers_allocateArrayFromCons } from "./Native.js";
 import { setItem as setItem_1, item as item_2 } from "./Array.js";
 import { value as value_2, map as map_1, defaultArg, some } from "./Option.js";
 import { min as min_1, max as max_1 } from "./Double.js";
-import { SR_indexOutOfBounds } from "./Global.js";
+import { SR_notEnoughElements, SR_inputMustBeNonNegative, SR_inputSequenceEmpty, SR_Arg_ArgumentOutOfRangeException, SR_indexOutOfBounds } from "./Global.js";
 import { Operators_IsNull } from "./FSharp.Core.js";
+import { nonSeeded } from "./Random.js";
 function indexNotFound() {
     throw new Exception("An index satisfying the predicate was not found in the collection.");
 }
@@ -1173,6 +1174,105 @@ export function insertManyAt(index, ys, xs, cons) {
     }
     return target;
 }
+export function randomShuffleInPlaceBy(randomizer, xs) {
+    const len = xs.length | 0;
+    for (let i = len - 1; i >= 1; i--) {
+        const r = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        const j = ~~(r * (i + 1)) | 0;
+        const tmp = item_2(i, xs);
+        setItem_1(xs, i, item_2(j, xs));
+        setItem_1(xs, j, tmp);
+    }
+}
+export function randomShuffleInPlaceWith(random, xs) {
+    randomShuffleInPlaceBy(() => random.NextDouble(), xs);
+}
+export function randomShuffleInPlace(xs) {
+    randomShuffleInPlaceWith(nonSeeded(), xs);
+}
+export function randomShuffleBy(randomizer, xs) {
+    const arr = copy(xs);
+    randomShuffleInPlaceBy(randomizer, arr);
+    return arr;
+}
+export function randomShuffleWith(random, xs) {
+    return randomShuffleBy(() => random.NextDouble(), xs);
+}
+export function randomShuffle(xs) {
+    return randomShuffleWith(nonSeeded(), xs);
+}
+export function randomChoiceBy(randomizer, xs) {
+    if (isEmpty(xs)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    const len = xs.length | 0;
+    const r = randomizer();
+    if ((r < 0) ? true : (r >= 1)) {
+        throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+    }
+    return item_2(~~(r * len), xs);
+}
+export function randomChoiceWith(random, xs) {
+    return randomChoiceBy(() => random.NextDouble(), xs);
+}
+export function randomChoice(xs) {
+    return randomChoiceWith(nonSeeded(), xs);
+}
+export function randomChoicesBy(randomizer, count, xs, cons) {
+    if (count < 0) {
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    if ((count > 0) && isEmpty(xs)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    const len = xs.length | 0;
+    return initialize(count, (_arg) => {
+        const r = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        return item_2(~~(r * len), xs);
+    }, cons);
+}
+export function randomChoicesWith(random, count, xs, cons) {
+    return randomChoicesBy(() => random.NextDouble(), count, xs, cons);
+}
+export function randomChoices(count, xs, cons) {
+    return randomChoicesWith(nonSeeded(), count, xs, cons);
+}
+export function randomSampleBy(randomizer, count, xs) {
+    if (count < 0) {
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    const arr = copy(xs);
+    const len = arr.length | 0;
+    if ((len === 0) && (count > 0)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    if (count > len) {
+        throw new Exception((SR_notEnoughElements + "\\nParameter name: ") + "count");
+    }
+    for (let i = 0; i <= (count - 1); i++) {
+        const r = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        const j = (i + ~~(r * (len - i))) | 0;
+        const tmp = item_2(i, arr);
+        setItem_1(arr, i, item_2(j, arr));
+        setItem_1(arr, j, tmp);
+    }
+    return getSubArray(arr, 0, count);
+}
+export function randomSampleWith(random, count, xs) {
+    return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+export function randomSample(count, xs) {
+    return randomSampleWith(nonSeeded(), count, xs);
+}
 export function removeAt(index, xs) {
     if ((index < 0) ? true : (index >= xs.length)) {
         throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");

package/Async.js

@@ -48,28 +48,19 @@ export function throwIfCancellationRequested(token) {
         throw new Exception("Operation is cancelled");
     }
 }
-function throwAfter(millisecondsDueTime) {
-    return protectedCont((ctx) => {
-        let tokenId;
-        const timeoutId = setTimeout(() => {
-            ctx.cancelToken.removeListener(tokenId);
-            ctx.onError(TimeoutException_$ctor());
-        }, millisecondsDueTime);
-        tokenId = ctx.cancelToken.addListener(() => {
-            clearTimeout(timeoutId);
-            ctx.onCancel(new OperationCanceledException());
-        });
-    });
-}
 export function startChild(computation, ms) {
+    const promise = startAsPromise(computation);
+    let promiseToRun = promise;
     if (ms) {
-        const computationWithTimeout = protectedBind(parallel2(computation, throwAfter(ms)), xs => protectedReturn(xs[0]));
-        return startChild(computationWithTimeout);
+        // 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); });
+        });
     }
-    const promise = startAsPromise(computation);
     // JS Promises are hot, computation has already started
     // but we delay returning the result
-    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));
+    return protectedCont((ctx) => protectedReturn(awaitPromise(promiseToRun))(ctx));
 }
 export function awaitPromise(p) {
     return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledException
@@ -99,9 +90,6 @@ export function ignore(computation) {
 export function parallel(computations) {
     return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
 }
-function parallel2(a, b) {
-    return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));
-}
 export function sequential(computations) {
     function _sequential(computations) {
         let pr = Promise.resolve([]);

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 2.0.0 - 2026-04-21
+
+### Fixed
+
+* [JS/TS] Fix `ResizeArray` (`System.Collections.Generic.List`) equality to use reference equality instead of structural equality (fixes #3718)
+* [JS/TS] Fix `String.Contains` ignoring `StringComparison` argument (second argument was silently discarded)
+
+## 2.0.0-rc.6 - 2026-04-07
+
+### Fixed
+
+* [JS/TS] Fix `Async.StartChild` with timeout always timing out even when the computation finishes before the deadline (fixes #4481) (by @MangelMaxime)
+
 ## 2.0.0-rc.5 - 2026-03-31
 
 ### Fixed

package/Guid.js

@@ -56,15 +56,33 @@ export function tryParse(str, defValue) {
         return false;
     }
 }
-// From https://gist.github.com/LeverOne/1308368
 export function newGuid() {
-    let b = "";
-    for (let a = 0; a++ < 36;) {
-        b += a * 51 & 52
-            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)
-            : "-";
-    }
-    return b;
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
+    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 1
+    const hex = Array.from(bytes, b => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+// RFC 9562 UUID v7
+export function createVersion7(timestamp) {
+    const ms = timestamp != null ? timestamp.getTime() : Date.now();
+    // 48-bit timestamp as hex
+    const msHex = Math.floor(ms).toString(16).padStart(12, "0");
+    // random bits
+    const bytes = new Uint8Array(10);
+    crypto.getRandomValues(bytes);
+    const view = new DataView(bytes.buffer);
+    const randA = view.getUint16(0) & 0x0fff; // 12 bits
+    const randB1 = view.getUint16(2) & 0x3fff; // 14 bits
+    const randB2 = view.getUint32(4); // 32 bits
+    const randB3 = view.getUint16(8); // 16 bits
+    const timeLow = msHex.slice(0, 8);
+    const timeMid = msHex.slice(8, 12);
+    const ver = (0x7000 | randA).toString(16).padStart(4, "0");
+    const variantAndRandB = (0x8000 | randB1).toString(16).padStart(4, "0");
+    const node = randB2.toString(16).padStart(8, "0") + randB3.toString(16).padStart(4, "0");
+    return `${timeLow}-${timeMid}-${ver}-${variantAndRandB}-${node}`;
 }
 // Maps for number <-> hex string conversion
 let _convertMapsInitialized = false;

package/List.js

@@ -5,7 +5,8 @@ import { Record } from "./Types.js";
 import { class_type, record_type, option_type } from "./Reflection.js";
 import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.js";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.js";
-import { transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, item as item_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, setItem, fill } from "./Array.js";
+import { randomSampleBy as randomSampleBy_1, randomChoicesBy as randomChoicesBy_1, randomChoiceBy as randomChoiceBy_1, randomShuffleInPlaceBy, transpose as transpose_1, splitInto as splitInto_1, windowed as windowed_1, pairwise as pairwise_1, chunkBySize as chunkBySize_1, map as map_1, permute as permute_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, scanBack as scanBack_1, item as item_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, setItem, fill } from "./Array.js";
+import { nonSeeded } from "./Random.js";
 export class FSharpList extends Record {
     constructor(head, tail) {
         super();
@@ -1282,3 +1283,41 @@ export function updateAt(index, y, xs) {
     }
     return ys;
 }
+export function randomShuffleBy(randomizer, xs) {
+    const arr = toArray(xs);
+    randomShuffleInPlaceBy(randomizer, arr);
+    return ofArray(arr);
+}
+export function randomShuffleWith(random, xs) {
+    return randomShuffleBy(() => random.NextDouble(), xs);
+}
+export function randomShuffle(xs) {
+    return randomShuffleWith(nonSeeded(), xs);
+}
+export function randomChoiceBy(randomizer, xs) {
+    return randomChoiceBy_1(randomizer, toArray(xs));
+}
+export function randomChoiceWith(random, xs) {
+    return randomChoiceBy(() => random.NextDouble(), xs);
+}
+export function randomChoice(xs) {
+    return randomChoiceWith(nonSeeded(), xs);
+}
+export function randomChoicesBy(randomizer, count, xs) {
+    return ofArray(randomChoicesBy_1(randomizer, count, toArray(xs)));
+}
+export function randomChoicesWith(random, count, xs) {
+    return randomChoicesBy(() => random.NextDouble(), count, xs);
+}
+export function randomChoices(count, xs) {
+    return randomChoicesWith(nonSeeded(), count, xs);
+}
+export function randomSampleBy(randomizer, count, xs) {
+    return ofArray(randomSampleBy_1(randomizer, count, toArray(xs)));
+}
+export function randomSampleWith(random, count, xs) {
+    return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+export function randomSample(count, xs) {
+    return randomSampleWith(nonSeeded(), count, xs);
+}

package/Seq.js

@@ -5,9 +5,11 @@ import { class_type } from "./Reflection.js";
 import { some, value as value_1 } from "./Option.js";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.js";
 import { Operators_Lock, Operators_NullArgCheck } from "./FSharp.Core.js";
-import { chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, item as item_1, tryItem as tryItem_1, tryHead as tryHead_1, foldBack2 as foldBack2_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.js";
+import { randomSampleBy as randomSampleBy_1, randomChoicesBy as randomChoicesBy_1, randomChoice as randomChoice_1, randomChoiceWith as randomChoiceWith_1, randomChoiceBy as randomChoiceBy_1, randomShuffleInPlaceBy, chunkBySize as chunkBySize_1, permute as permute_1, transpose as transpose_1, map as map_1, windowed as windowed_1, splitInto as splitInto_1, pairwise as pairwise_1, scanBack as scanBack_1, reverse as reverse_1, mapFoldBack as mapFoldBack_1, mapFold as mapFold_1, tryItem as tryItem_1, tryHead as tryHead_1, item as item_1, foldBack as foldBack_1, tryFindIndexBack as tryFindIndexBack_1, tryFindBack as tryFindBack_1, singleton as singleton_1 } from "./Array.js";
 import { length as length_1, tryItem as tryItem_2, isEmpty as isEmpty_1, tryHead as tryHead_2, ofSeq as ofSeq_1, ofArray as ofArray_1, toArray as toArray_1, FSharpList } from "./List.js";
+import { min as min_1 } from "./Double.js";
 import { SR_indexOutOfBounds } from "./Global.js";
+import { nonSeeded } from "./Random.js";
 export const SR_enumerationAlreadyFinished = "Enumeration already finished.";
 export const SR_enumerationNotStarted = "Enumeration has not started. Call MoveNext.";
 export const SR_inputSequenceEmpty = "The input sequence was empty.";
@@ -655,7 +657,14 @@ export function fold2(folder, state, xs, ys) {
     }
 }
 export function foldBack2(folder, xs, ys, state) {
-    return foldBack2_1(folder, toArray(xs), toArray(ys), state);
+    const xs_1 = toArray(xs);
+    const ys_1 = toArray(ys);
+    const len = min_1(xs_1.length, ys_1.length) | 0;
+    let acc = state;
+    for (let i = len - 1; i >= 0; i--) {
+        acc = folder(item_1(i, xs_1), item_1(i, ys_1), acc);
+    }
+    return acc;
 }
 export function forAll(predicate, xs) {
     return !exists((x) => !predicate(x), xs);
@@ -1368,3 +1377,41 @@ export function updateAt(index, y, xs) {
         disposeSafe(e_1);
     });
 }
+export function randomShuffleBy(randomizer, xs) {
+    const arr = toArray(xs);
+    randomShuffleInPlaceBy(randomizer, arr);
+    return ofArray(arr);
+}
+export function randomShuffleWith(random, xs) {
+    return randomShuffleBy(() => random.NextDouble(), xs);
+}
+export function randomShuffle(xs) {
+    return randomShuffleWith(nonSeeded(), xs);
+}
+export function randomChoiceBy(randomizer, xs) {
+    return randomChoiceBy_1(randomizer, toArray(xs));
+}
+export function randomChoiceWith(random, xs) {
+    return randomChoiceWith_1(random, toArray(xs));
+}
+export function randomChoice(xs) {
+    return randomChoice_1(toArray(xs));
+}
+export function randomChoicesBy(randomizer, count, xs) {
+    return ofArray(randomChoicesBy_1(randomizer, count, toArray(xs)));
+}
+export function randomChoicesWith(random, count, xs) {
+    return randomChoicesBy(() => random.NextDouble(), count, xs);
+}
+export function randomChoices(count, xs) {
+    return randomChoicesWith(nonSeeded(), count, xs);
+}
+export function randomSampleBy(randomizer, count, xs) {
+    return ofArray(randomSampleBy_1(randomizer, count, toArray(xs)));
+}
+export function randomSampleWith(random, count, xs) {
+    return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+export function randomSample(count, xs) {
+    return randomSampleWith(nonSeeded(), count, xs);
+}