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

package/Array.ts

@@ -1,12 +1,13 @@
 
 import { IComparer, IDisposable, disposeSafe, IEnumerator, getEnumerator, copyToArray, IEqualityComparer, defaultOf, MutableArray, Exception } from "./Util.ts";
-import { int32 } from "./Int32.ts";
+import { float64, int32 } from "./Int32.ts";
 import { Helpers_allocateArrayFromCons } from "./Native.ts";
 import { setItem as setItem_1, item as item_2 } from "./Array.ts";
 import { value as value_2, map as map_1, defaultArg, Option, some } from "./Option.ts";
 import { min as min_1, max as max_1 } from "./Double.ts";
-import { SR_indexOutOfBounds } from "./Global.ts";
+import { SR_notEnoughElements, SR_inputMustBeNonNegative, SR_inputSequenceEmpty, SR_Arg_ArgumentOutOfRangeException, SR_indexOutOfBounds } from "./Global.ts";
 import { Operators_IsNull } from "./FSharp.Core.ts";
+import { nonSeeded } from "./Random.ts";
 import { FSharpRef } from "./Types.ts";
 
 function indexNotFound<$a>(): $a {
@@ -1307,6 +1308,120 @@ export function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: MutableArray<
     return target;
 }
 
+export function randomShuffleInPlaceBy<T>(randomizer: (() => float64), xs: MutableArray<T>): void {
+    const len: int32 = xs.length | 0;
+    for (let i: int32 = len - 1; i >= 1; i--) {
+        const r: float64 = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        const j: int32 = ~~(r * (i + 1)) | 0;
+        const tmp: T = item_2(i, xs);
+        setItem_1(xs, i, item_2(j, xs));
+        setItem_1(xs, j, tmp);
+    }
+}
+
+export function randomShuffleInPlaceWith<T>(random: any, xs: MutableArray<T>): void {
+    randomShuffleInPlaceBy<T>((): float64 => random.NextDouble(), xs);
+}
+
+export function randomShuffleInPlace<T>(xs: MutableArray<T>): void {
+    randomShuffleInPlaceWith<T>(nonSeeded(), xs);
+}
+
+export function randomShuffleBy<T>(randomizer: (() => float64), xs: MutableArray<T>): MutableArray<T> {
+    const arr: MutableArray<T> = copy<T>(xs);
+    randomShuffleInPlaceBy<T>(randomizer, arr);
+    return arr;
+}
+
+export function randomShuffleWith<T>(random: any, xs: MutableArray<T>): MutableArray<T> {
+    return randomShuffleBy<T>((): float64 => random.NextDouble(), xs);
+}
+
+export function randomShuffle<T>(xs: MutableArray<T>): MutableArray<T> {
+    return randomShuffleWith<T>(nonSeeded(), xs);
+}
+
+export function randomChoiceBy<T>(randomizer: (() => float64), xs: MutableArray<T>): T {
+    if (isEmpty<T>(xs)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    const len: int32 = xs.length | 0;
+    const r: float64 = 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<T>(random: any, xs: MutableArray<T>): T {
+    return randomChoiceBy<T>((): float64 => random.NextDouble(), xs);
+}
+
+export function randomChoice<T>(xs: MutableArray<T>): T {
+    return randomChoiceWith<T>(nonSeeded(), xs);
+}
+
+export function randomChoicesBy<T>(randomizer: (() => float64), count: int32, xs: MutableArray<T>, cons?: any): MutableArray<T> {
+    if (count < 0) {
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    if ((count > 0) && isEmpty<T>(xs)) {
+        throw new Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "source");
+    }
+    const len: int32 = xs.length | 0;
+    return initialize<T>(count, (_arg: int32): T => {
+        const r: float64 = 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<T>(random: any, count: int32, xs: MutableArray<T>, cons?: any): MutableArray<T> {
+    return randomChoicesBy<T>((): float64 => random.NextDouble(), count, xs, cons);
+}
+
+export function randomChoices<T>(count: int32, xs: MutableArray<T>, cons?: any): MutableArray<T> {
+    return randomChoicesWith<T>(nonSeeded(), count, xs, cons);
+}
+
+export function randomSampleBy<T>(randomizer: (() => float64), count: int32, xs: MutableArray<T>): MutableArray<T> {
+    if (count < 0) {
+        throw new Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count");
+    }
+    const arr: MutableArray<T> = copy<T>(xs);
+    const len: int32 = 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: float64 = randomizer();
+        if ((r < 0) ? true : (r >= 1)) {
+            throw new Exception((SR_Arg_ArgumentOutOfRangeException + "\\nParameter name: ") + "randomizer");
+        }
+        const j: int32 = (i + ~~(r * (len - i))) | 0;
+        const tmp: T = item_2(i, arr);
+        setItem_1(arr, i, item_2(j, arr));
+        setItem_1(arr, j, tmp);
+    }
+    return getSubArray<T>(arr, 0, count);
+}
+
+export function randomSampleWith<T>(random: any, count: int32, xs: MutableArray<T>): MutableArray<T> {
+    return randomSampleBy<T>((): float64 => random.NextDouble(), count, xs);
+}
+
+export function randomSample<T>(count: int32, xs: MutableArray<T>): MutableArray<T> {
+    return randomSampleWith<T>(nonSeeded(), count, xs);
+}
+
 export function removeAt<T>(index: int32, xs: MutableArray<T>): MutableArray<T> {
     if ((index < 0) ? true : (index >= xs.length)) {
         throw new Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index");

package/Async.ts

@@ -58,37 +58,25 @@ export function throwIfCancellationRequested(token: CancellationToken) {
   }
 }
 
-function throwAfter(millisecondsDueTime: number): Async<void> {
-  return protectedCont((ctx: IAsyncContext<void>) => {
-    let tokenId: number;
-    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<T>(computation: Async<T>, ms?: number): Async<Async<T>> {
-  if (ms) {
-    const computationWithTimeout = protectedBind(
-      parallel2(
-        computation,
-        throwAfter(ms)),
-      xs => protectedReturn(xs[0]));
+  const promise = startAsPromise(computation);
+  let promiseToRun = promise;
 
-    return startChild(computationWithTimeout);
+  if (ms) {
+    // Race the computation against a timeout: whichever settles first wins.
+    promiseToRun = new Promise<T>((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));
+    protectedReturn(awaitPromise(promiseToRun))(ctx));
 }
 
 export function awaitPromise<T>(p: Promise<T>) {
@@ -129,10 +117,6 @@ export function parallel<T>(computations: Iterable<Async<T>>) {
   return delay(() => awaitPromise(Promise.all(Array.from(computations, (w) => startAsPromise(w)))));
 }
 
-function parallel2<T, U>(a: Async<T>, b: Async<U>): Async<[T, U]> {
-  return delay(() => awaitPromise(Promise.all([startAsPromise(a), startAsPromise(b)])));
-}
-
 export function sequential<T>(computations: Iterable<Async<T>>) {
 
   function _sequential<T>(computations: Iterable<Async<T>>): Promise<T[]> {

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.ts

@@ -63,15 +63,38 @@ export function tryParse(str: string, defValue: FSharpRef<string>): boolean {
   }
 }
 
-// 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?: Date): string {
+  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

package/List.ts

@@ -2,12 +2,13 @@
 import { join } from "./String.ts";
 import { defaultArg, some, value as value_1, Option } from "./Option.ts";
 import { IComparer, IEqualityComparer, disposeSafe, isArrayLike, MutableArray, Exception, IDisposable, defaultOf, toIterator, getEnumerator, IEnumerator, compare, structuralHash, equals } from "./Util.ts";
-import { int32 } from "./Int32.ts";
+import { float64, int32 } from "./Int32.ts";
 import { Record } from "./Types.ts";
 import { class_type, record_type, option_type, TypeInfo } from "./Reflection.ts";
 import { SR_inputSequenceTooLong, SR_inputSequenceEmpty, SR_inputMustBeNonNegative, SR_notEnoughElements, SR_differentLengths, SR_keyNotFoundAlt, SR_indexOutOfBounds, SR_inputWasEmpty } from "./Global.ts";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.ts";
-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.ts";
+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.ts";
+import { nonSeeded } from "./Random.ts";
 
 export class FSharpList<T> extends Record implements Iterable<T> {
     readonly head: T;
@@ -1427,3 +1428,53 @@ export function updateAt<T>(index: int32, y: T, xs: FSharpList<T>): FSharpList<T
     return ys;
 }
 
+export function randomShuffleBy<T>(randomizer: (() => float64), xs: FSharpList<T>): FSharpList<T> {
+    const arr: MutableArray<T> = toArray<T>(xs);
+    randomShuffleInPlaceBy<T>(randomizer, arr);
+    return ofArray<T>(arr);
+}
+
+export function randomShuffleWith<T>(random: any, xs: FSharpList<T>): FSharpList<T> {
+    return randomShuffleBy<T>((): float64 => random.NextDouble(), xs);
+}
+
+export function randomShuffle<T>(xs: FSharpList<T>): FSharpList<T> {
+    return randomShuffleWith<T>(nonSeeded(), xs);
+}
+
+export function randomChoiceBy<T>(randomizer: (() => float64), xs: FSharpList<T>): T {
+    return randomChoiceBy_1<T>(randomizer, toArray<T>(xs));
+}
+
+export function randomChoiceWith<T>(random: any, xs: FSharpList<T>): T {
+    return randomChoiceBy<T>((): float64 => random.NextDouble(), xs);
+}
+
+export function randomChoice<T>(xs: FSharpList<T>): T {
+    return randomChoiceWith<T>(nonSeeded(), xs);
+}
+
+export function randomChoicesBy<T>(randomizer: (() => float64), count: int32, xs: FSharpList<T>): FSharpList<T> {
+    return ofArray<T>(randomChoicesBy_1<T>(randomizer, count, toArray<T>(xs)));
+}
+
+export function randomChoicesWith<T>(random: any, count: int32, xs: FSharpList<T>): FSharpList<T> {
+    return randomChoicesBy<T>((): float64 => random.NextDouble(), count, xs);
+}
+
+export function randomChoices<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
+    return randomChoicesWith<T>(nonSeeded(), count, xs);
+}
+
+export function randomSampleBy<T>(randomizer: (() => float64), count: int32, xs: FSharpList<T>): FSharpList<T> {
+    return ofArray<T>(randomSampleBy_1<T>(randomizer, count, toArray<T>(xs)));
+}
+
+export function randomSampleWith<T>(random: any, count: int32, xs: FSharpList<T>): FSharpList<T> {
+    return randomSampleBy<T>((): float64 => random.NextDouble(), count, xs);
+}
+
+export function randomSample<T>(count: int32, xs: FSharpList<T>): FSharpList<T> {
+    return randomSampleWith<T>(nonSeeded(), count, xs);
+}
+

package/Seq.ts

@@ -6,10 +6,12 @@ import { class_type, TypeInfo } from "./Reflection.ts";
 import { some, value as value_1, Option } from "./Option.ts";
 import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.ts";
 import { Operators_Lock, Operators_NullArgCheck } from "./FSharp.Core.ts";
-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.ts";
+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.ts";
 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.ts";
-import { int32 } from "./Int32.ts";
+import { float64, int32 } from "./Int32.ts";
+import { min as min_1 } from "./Double.ts";
 import { SR_indexOutOfBounds } from "./Global.ts";
+import { nonSeeded } from "./Random.ts";
 
 export const SR_enumerationAlreadyFinished = "Enumeration already finished.";
 
@@ -723,7 +725,14 @@ export function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2)
 }
 
 export function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: Iterable<T1>, ys: Iterable<T2>, state: State): State {
-    return foldBack2_1<T1, T2, State>(folder, toArray<T1>(xs), toArray<T2>(ys), state);
+    const xs_1: MutableArray<T1> = toArray<T1>(xs);
+    const ys_1: MutableArray<T2> = toArray<T2>(ys);
+    const len: int32 = min_1(xs_1.length, ys_1.length) | 0;
+    let acc: State = state;
+    for (let i: int32 = len - 1; i >= 0; i--) {
+        acc = folder(item_1(i, xs_1), item_1(i, ys_1), acc);
+    }
+    return acc;
 }
 
 export function forAll<$a>(predicate: ((arg0: $a) => boolean), xs: Iterable<$a>): boolean {
@@ -1515,3 +1524,53 @@ export function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T> {
     });
 }
 
+export function randomShuffleBy<T>(randomizer: (() => float64), xs: Iterable<T>): Iterable<T> {
+    const arr: MutableArray<T> = toArray<T>(xs);
+    randomShuffleInPlaceBy<T>(randomizer, arr);
+    return ofArray<T>(arr);
+}
+
+export function randomShuffleWith<T>(random: any, xs: Iterable<T>): Iterable<T> {
+    return randomShuffleBy<T>((): float64 => random.NextDouble(), xs);
+}
+
+export function randomShuffle<T>(xs: Iterable<T>): Iterable<T> {
+    return randomShuffleWith<T>(nonSeeded(), xs);
+}
+
+export function randomChoiceBy<T>(randomizer: (() => float64), xs: Iterable<T>): T {
+    return randomChoiceBy_1<T>(randomizer, toArray<T>(xs));
+}
+
+export function randomChoiceWith<T>(random: any, xs: Iterable<T>): T {
+    return randomChoiceWith_1<T>(random, toArray<T>(xs));
+}
+
+export function randomChoice<T>(xs: Iterable<T>): T {
+    return randomChoice_1<T>(toArray<T>(xs));
+}
+
+export function randomChoicesBy<T>(randomizer: (() => float64), count: int32, xs: Iterable<T>): Iterable<T> {
+    return ofArray<T>(randomChoicesBy_1<T>(randomizer, count, toArray<T>(xs)));
+}
+
+export function randomChoicesWith<T>(random: any, count: int32, xs: Iterable<T>): Iterable<T> {
+    return randomChoicesBy<T>((): float64 => random.NextDouble(), count, xs);
+}
+
+export function randomChoices<T>(count: int32, xs: Iterable<T>): Iterable<T> {
+    return randomChoicesWith<T>(nonSeeded(), count, xs);
+}
+
+export function randomSampleBy<T>(randomizer: (() => float64), count: int32, xs: Iterable<T>): Iterable<T> {
+    return ofArray<T>(randomSampleBy_1<T>(randomizer, count, toArray<T>(xs)));
+}
+
+export function randomSampleWith<T>(random: any, count: int32, xs: Iterable<T>): Iterable<T> {
+    return randomSampleBy<T>((): float64 => random.NextDouble(), count, xs);
+}
+
+export function randomSample<T>(count: int32, xs: Iterable<T>): Iterable<T> {
+    return randomSampleWith<T>(nonSeeded(), count, xs);
+}
+