@fable-org/fable-library-ts 2.2.0 → 2.4.0

package/Async.ts

@@ -2,6 +2,7 @@ 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 type { IEvent$2 } from "./Event.ts";
 import { FSharpChoice$2_$union, Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.ts";
 import { TimeoutException_$ctor } from "./System.ts";
 import { Exception } from "./Util.ts";
@@ -86,6 +87,23 @@ export function awaitPromise<T>(p: Promise<T>) {
         ? conts[2] : conts[1])(err)));
 }
 
+export function awaitEvent<Del extends Function, T>(event: IEvent$2<Del, T>, cancelAction?: () => void): Async<T> {
+  return protectedCont((ctx: IAsyncContext<T>) => {
+    let tokenId: number;
+    const handler = ((_sender: unknown, arg: T) => {
+      ctx.cancelToken.removeListener(tokenId);
+      event.RemoveHandler(handler as unknown as Del);
+      ctx.onSuccess(arg);
+    }) as unknown as Del;
+    tokenId = ctx.cancelToken.addListener(() => {
+      event.RemoveHandler(handler);
+      if (cancelAction != null) { cancelAction(); }
+      ctx.onCancel(new OperationCanceledException());
+    });
+    event.AddHandler(handler);
+  });
+}
+
 export function cancellationToken() {
   return protectedCont((ctx: IAsyncContext<CancellationToken>) => ctx.onSuccess(ctx.cancelToken));
 }

package/CHANGELOG.md

@@ -1,5 +1,5 @@
 ---
-last_commit_released: c9b3ee2429a4688946c1936e27df730837428070
+last_commit_released: 7f915f1dd66b9a5fbbd56f858b07d39b98519b65
 updaters:
   - package.json:
       file: package.json
@@ -15,6 +15,35 @@ 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.4.0 - 2026-07-05
+
+### 🚀 Features
+
+* *(js/ts)* Add `System.IO.Path` and `System.IO.File` API support ([ec99fac5](https://github.com/fable-compiler/Fable/commit/ec99fac5fd7a9428ee54f66f878ef4edad0904cb))
+* *(js/ts/python)* Add Environment and Console.Error support ([6e082f95](https://github.com/fable-compiler/Fable/commit/6e082f955140676da3388a43b55378ea4ad20f1c))
+
+### 🐞 Bug Fixes
+
+* *(js/ts)* DateTime.ToString() and %A are now consistent across all DateTimeKind values (#4714) ([de98b0e4](https://github.com/fable-compiler/Fable/commit/de98b0e466c8824b0ba8b941d20efae70d232abb))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/c977d78b39225a51c7bd051a1fe363ed0ccbe201..7f915f1dd66b9a5fbbd56f858b07d39b98519b65)</small></strong>
+
+## 2.3.0 - 2026-06-30
+
+### 🚀 Features
+
+* *(js/ts)* Map task { } to Promise<T> ([97f54d36](https://github.com/fable-compiler/Fable/commit/97f54d3692e5ba881c249b289c20b4fad5ac27e2))
+* *(js/ts/python/beam)* Add support for `Async.AwaitEvent` (#4693) ([71c98179](https://github.com/fable-compiler/Fable/commit/71c981792b6ff99cd417bb2e70a13a9d55ed72cf))
+
+### 🐞 Bug Fixes
+
+* *(js)* Respect StringComparison in String.IndexOf/LastIndexOf (#4681) ([7cb92d52](https://github.com/fable-compiler/Fable/commit/7cb92d522e5dc8dfe51351565504c59a94c2f408))
+* *(js/ts)* Int list is not a union type (#4698) ([ecbecbe7](https://github.com/fable-compiler/Fable/commit/ecbecbe756610fd83a621c005e97eda92bbc332a))
+* *(js/ts)* Pass TypeInfo to getRecordFields to handle None fields in anonymous records (#4704) ([c977d78b](https://github.com/fable-compiler/Fable/commit/c977d78b39225a51c7bd051a1fe363ed0ccbe201))
+* *(ts)* Widen isEnumDefined value parameter to accept any value (#4690) ([0d6498dd](https://github.com/fable-compiler/Fable/commit/0d6498ddf65e0e18918690633da23b04b78479f6))
+
+<strong><small>[View changes on Github](https://github.com/fable-compiler/Fable/compare/c9b3ee2429a4688946c1936e27df730837428070..c977d78b39225a51c7bd051a1fe363ed0ccbe201)</small></strong>
+
 ## 2.2.0 - 2026-06-24
 
 ### 🚀 Features

package/Date.ts

@@ -509,7 +509,7 @@ function dateToString_Y(date: IDateTime) {
 function dateToStringWithKind(date: IDateTime, format?: string) {
   const utc = date.kind === DateTimeKind.Utc;
   if (typeof format !== "string") {
-    return utc ? date.toUTCString() : date.toLocaleString();
+    return dateToString_d(date) + " " + dateToString_T(date);
   } else if (format.length === 1) {
     switch (format) {
       case "D": return dateToString_D(date);

package/Environment.ts

@@ -0,0 +1,7 @@
+// process.env is Node-specific; there is no browser equivalent for reading
+// environment variables, so this only works when running under Node.
+declare const process: { env: Record<string, string | undefined> };
+
+export function getEnvironmentVariable(name: string): string {
+  return process.env[name] as string;
+}

package/File.ts

@@ -0,0 +1,35 @@
+// 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 { readFileSync, writeFileSync } from "node:fs";
+import { MutableArray } from "./Util.ts";
+
+// byte[] is represented as a plain JS/TS array of numbers, not a typed array
+// (see e.g. BitConverter.ts), so convert the Buffer returned by readFileSync.
+export function readAllBytes(path: string): number[] {
+  return Array.from(readFileSync(path));
+}
+
+export function readAllLines(path: string): string[] {
+  const lines = readFileSync(path, "utf8").split(/\r\n|\r|\n/);
+
+  if (lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+
+  return lines;
+}
+
+export function readAllText(path: string): string {
+  return readFileSync(path, "utf8");
+}
+
+export function writeAllBytes(path: string, bytes: MutableArray<number>): void {
+  // Convert back from the plain array representation to a typed array Node's fs accepts.
+  writeFileSync(path, Uint8Array.from(bytes));
+}
+
+export function writeAllLines(path: string, lines: MutableArray<string>): void {
+  writeFileSync(path, lines.join("\n"));
+}

package/Path.ts

@@ -0,0 +1,37 @@
+// This library doesn't depend on @types/node (to stay browser-compatible),
+// so these Node.js built-in imports can't be type-checked; the exported
+// functions below still declare their own types for callers to rely on.
+// @ts-ignore
+import { basename, extname, join } from "node:path";
+// @ts-ignore
+import { tmpdir } from "node:os";
+// @ts-ignore
+import { writeFileSync } from "node:fs";
+
+// Mirrors the format of .NET's Path.GetRandomFileName(): 8 random hex chars,
+// a dot, then 3 more random hex chars.
+export function getRandomFileName(): string {
+  const nameBytes = new Uint8Array(4);
+  crypto.getRandomValues(nameBytes);
+  const name = Array.from(nameBytes, (b) => b.toString(16).padStart(2, "0")).join("");
+
+  const extBytes = new Uint8Array(2);
+  crypto.getRandomValues(extBytes);
+  const ext = Array.from(extBytes, (b) => b.toString(16).padStart(2, "0")).join("").slice(0, 3);
+
+  return `${name}.${ext}`;
+}
+
+export function getFileNameWithoutExtension(path: string): string {
+  return basename(path, extname(path));
+}
+
+export function hasExtension(path: string): boolean {
+  return extname(path) !== "";
+}
+
+export function getTempFileName(): string {
+  const path = join(tmpdir(), getRandomFileName());
+  writeFileSync(path, "");
+  return path;
+}

package/Reflection.ts

@@ -171,7 +171,18 @@ export function option_type(generic: TypeInfo): TypeInfo {
 }
 
 export function list_type(generic: TypeInfo): TypeInfo {
-  return new TypeInfo("Microsoft.FSharp.Collections.FSharpList`1", [generic]);
+  const t: TypeInfo = new TypeInfo(
+    "Microsoft.FSharp.Collections.FSharpList`1",
+    [generic],
+    undefined,
+    undefined,
+    undefined,
+    () => [
+      new CaseInfo(t, 0, "Empty"),
+      new CaseInfo(t, 1, "Cons", [["Head", generic], ["Tail", t]])
+    ]
+  );
+  return t;
 }
 
 export function array_type(generic: TypeInfo): TypeInfo {
@@ -389,7 +400,7 @@ export function getEnumName(t: TypeInfo, v: number): string {
   return getEnumCase(t, v)[0];
 }
 
-export function isEnumDefined(t: TypeInfo, v: string | number): boolean {
+export function isEnumDefined(t: TypeInfo, v: any): boolean {
   try {
     const kv = getEnumCase(t, v);
     return kv[0] != null && kv[0] !== "";
@@ -477,8 +488,14 @@ export function getUnionCaseFields(uci: CaseInfo): FieldInfo[] {
 
 // This is used as replacement of `FSharpValue.GetRecordFields`
 // For `FSharpTypes.GetRecordFields` see `getRecordElements`
-// Object.keys returns keys in the order they were added to the object
-export function getRecordFields(v: any): MutableArray<any> {
+// TypeInfo is used when available to enumerate fields by name: anonymous record None fields
+// are omitted from the JS object, so Object.keys alone would miss them.
+// Boxed anonymous record would are still not covered but this is the best we can do for now
+// without adding a __fields__ to every anonymous record being created
+export function getRecordFields(v: any, t: TypeInfo): MutableArray<any> {
+  if (t.fields != null) {
+    return t.fields().map(([key, _]) => v[key]);
+  }
   return Object.keys(v).map((k) => v[k]);
 }
 

package/String.ts

@@ -99,6 +99,32 @@ export function contains(str: string, pattern: string, ic: boolean | StringCompa
   return false;
 }
 
+export function indexOf(str: string, searchValue: string, comparison: StringComparison, startIndex: number = 0): number {
+  if (comparison === StringComparison.Ordinal) { // fast path
+    return str.indexOf(searchValue, startIndex);
+  }
+  const len = searchValue.length;
+  for (let i = Math.max(startIndex, 0); i <= str.length - len; i++) {
+    if (cmp(str.slice(i, i + len), searchValue, comparison) === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export function lastIndexOf(str: string, searchValue: string, comparison: StringComparison, startIndex: number = str.length - 1): number {
+  if (comparison === StringComparison.Ordinal) { // fast path
+    return str.lastIndexOf(searchValue, startIndex);
+  }
+  const len = searchValue.length;
+  for (let i = Math.min(startIndex, str.length - len); i >= 0; i--) {
+    if (cmp(str.slice(i, i + len), searchValue, comparison) === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 export function indexOfAny(str: string, anyOf: string[], ...args: number[]) {
   if (str == null || str === "") {
     return -1;

package/Task.ts

@@ -0,0 +1,37 @@
+import { OperationCanceledException } from "./AsyncBuilder.ts";
+
+export class TaskCompletionSource<T> {
+  private _resolve!: (value: T) => void;
+  private _reject!: (reason?: unknown) => void;
+  public task: Promise<T>;
+
+  constructor() {
+    this.task = new Promise<T>((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+
+  SetResult(value: T): void { this._resolve(value); }
+  SetException(error: unknown): void { this._reject(error); }
+  SetCancelled(): void { this._reject(new OperationCanceledException()); }
+  get_Task(): Promise<T> { return this.task; }
+}
+
+export function fromResult<T>(value: T): Promise<T> {
+  return Promise.resolve(value);
+}
+
+export function zero(): Promise<void> {
+  return Promise.resolve();
+}
+
+// Task<T> = Promise<T> in JS/TS. GetAwaiter/GetResult return the Promise itself;
+// callers should use Async.AwaitTask to extract the value in an async context.
+export function getAwaiter<T>(t: Promise<T>): Promise<T> {
+  return t;
+}
+
+export function getResult<T>(t: Promise<T>): Promise<T> {
+  return t;
+}

package/TaskBuilder.ts

@@ -0,0 +1,85 @@
+import { IDisposable } from "./Util.ts";
+import { zero } from "./Task.ts";
+
+export class TaskBuilder {
+  public Bind<T, U>(computation: Promise<T>, binder: (x: T) => Promise<U>): Promise<U> {
+    return computation.then(binder);
+  }
+
+  public Combine<T>(computation1: Promise<void>, computation2: () => Promise<T>): Promise<T> {
+    return computation1.then(computation2);
+  }
+
+  public Delay<T>(generator: () => Promise<T>): () => Promise<T> {
+    return generator;
+  }
+
+  public For<T>(sequence: Iterable<T>, body: (x: T) => Promise<void>): Promise<void> {
+    const iter = sequence[Symbol.iterator]();
+    let cur = iter.next();
+    return this.While(
+      () => !cur.done,
+      this.Delay(() => {
+        const res = body(cur.value!);
+        cur = iter.next();
+        return res;
+      })
+    );
+  }
+
+  public Return<T>(value?: T): Promise<T | undefined> {
+    return Promise.resolve(value);
+  }
+
+  public ReturnFrom<T>(computation: Promise<T>): Promise<T> {
+    return computation;
+  }
+
+  public TryFinally<T>(computation: () => Promise<T>, compensation: () => void): Promise<T> {
+    try {
+      return computation().finally(compensation);
+    } catch (e) {
+      compensation();
+      return Promise.reject(e);
+    }
+  }
+
+  public TryWith<T>(computation: () => Promise<T>, catchHandler: (e: unknown) => Promise<T>): Promise<T> {
+    try {
+      return computation().catch(catchHandler);
+    } catch (e) {
+      try {
+        return catchHandler(e);
+      } catch (e2) {
+        return Promise.reject(e2);
+      }
+    }
+  }
+
+  public Using<T extends IDisposable, U>(resource: T, binder: (x: T) => Promise<U>): Promise<U> {
+    return this.TryFinally(() => binder(resource), () => resource.Dispose());
+  }
+
+  public While(guard: () => boolean, computation: () => Promise<void>): Promise<void> {
+    return (async () => {
+      while (guard()) {
+        await computation();
+      }
+    })();
+  }
+
+  public Zero(): Promise<void> {
+    return zero();
+  }
+
+  public Run<T>(computation: () => Promise<T>): Promise<T> {
+    try {
+      return computation();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+}
+
+export const singleton = new TaskBuilder();
+export function task(): TaskBuilder { return singleton; }

package/package.json

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