@fable-org/fable-library-js 1.4.3 → 1.6.0

package/Async.d.ts

@@ -1,32 +1,27 @@
 import { Continuation, Continuations } from "./AsyncBuilder.js";
-import { CancellationToken } from "./AsyncBuilder.js";
-import { IAsync } from "./AsyncBuilder.js";
-import { IAsyncContext } from "./AsyncBuilder.js";
+import { Async, IAsyncContext, CancellationToken } from "./AsyncBuilder.js";
 import { FSharpChoice$2_$union } from "./Choice.js";
-export declare class Async<_T> {
-}
-export declare function makeAsync<T>(body: IAsync<T>): IAsync<T>;
-export declare function invoke<T>(computation: IAsync<T>, ctx: IAsyncContext<T>): void;
-export declare function callThenInvoke<T, U>(ctx: IAsyncContext<T>, result1: U, part2: (x: U) => IAsync<T>): void;
-export declare function bind<T, U>(ctx: IAsyncContext<T>, part1: IAsync<U>, part2: (x: U) => IAsync<T>): void;
+export declare function makeAsync<T>(body: Async<T>): Async<T>;
+export declare function invoke<T>(computation: Async<T>, ctx: IAsyncContext<T>): void;
+export declare function callThenInvoke<T, U>(ctx: IAsyncContext<T>, result1: U, part2: (x: U) => Async<T>): void;
+export declare function bind<T, U>(ctx: IAsyncContext<T>, part1: Async<U>, part2: (x: U) => Async<T>): void;
 export declare function createCancellationToken(arg?: boolean | number): CancellationToken;
 export declare function cancel(token: CancellationToken): void;
 export declare function cancelAfter(token: CancellationToken, ms: number): void;
 export declare function isCancellationRequested(token: CancellationToken): boolean;
 export declare function throwIfCancellationRequested(token: CancellationToken): void;
-export declare function startChild<T>(computation: IAsync<T>, ms?: number): IAsync<IAsync<T>>;
+export declare function startChild<T>(computation: Async<T>, ms?: number): Async<Async<T>>;
 export declare function awaitPromise<T>(p: Promise<T>): (ctx: IAsyncContext<T>) => void;
 export declare function cancellationToken(): (ctx: IAsyncContext<CancellationToken>) => void;
 export declare const defaultCancellationToken: CancellationToken;
-export declare function catchAsync<T>(work: IAsync<T>): (ctx: IAsyncContext<FSharpChoice$2_$union<T, Error>>) => void;
+export declare function catchAsync<T>(work: Async<T>): (ctx: IAsyncContext<FSharpChoice$2_$union<T, Error>>) => void;
 export declare function fromContinuations<T>(f: (conts: Continuations<T>) => void): (ctx: IAsyncContext<T>) => void;
-export declare function ignore<T>(computation: IAsync<T>): (ctx: IAsyncContext<undefined>) => void;
-export declare function parallel<T>(computations: Iterable<IAsync<T>>): (ctx: IAsyncContext<Awaited<T>[]>) => void;
-export declare function sequential<T>(computations: Iterable<IAsync<T>>): (ctx: IAsyncContext<T[]>) => void;
+export declare function ignore<T>(computation: Async<T>): (ctx: IAsyncContext<undefined>) => void;
+export declare function parallel<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<Awaited<T>[]>) => void;
+export declare function sequential<T>(computations: Iterable<Async<T>>): (ctx: IAsyncContext<T[]>) => void;
 export declare function sleep(millisecondsDueTime: number): (ctx: IAsyncContext<void>) => void;
 export declare function runSynchronously(): never;
-export declare function start<T>(computation: IAsync<T>, cancellationToken?: CancellationToken): void;
-export declare function startImmediate<T>(computation: IAsync<T>, cancellationToken?: CancellationToken): void;
-export declare function startWithContinuations<T>(computation: IAsync<T>, continuation?: Continuation<T> | CancellationToken, exceptionContinuation?: Continuation<any>, cancellationContinuation?: Continuation<any>, cancelToken?: CancellationToken): void;
-export declare function startAsPromise<T>(computation: IAsync<T>, cancellationToken?: CancellationToken): Promise<T>;
-export default Async;
+export declare function start<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
+export declare function startImmediate<T>(computation: Async<T>, cancellationToken?: CancellationToken): void;
+export declare function startWithContinuations<T>(computation: Async<T>, continuation?: Continuation<T> | CancellationToken, exceptionContinuation?: Continuation<any>, cancellationContinuation?: Continuation<any>, cancelToken?: CancellationToken): void;
+export declare function startAsPromise<T>(computation: Async<T>, cancellationToken?: CancellationToken): Promise<T>;

package/Async.js

@@ -1,13 +1,8 @@
 import { OperationCanceledError, Trampoline } from "./AsyncBuilder.js";
 import { CancellationToken } from "./AsyncBuilder.js";
-import { protectedCont } from "./AsyncBuilder.js";
-import { protectedBind } from "./AsyncBuilder.js";
-import { protectedReturn } from "./AsyncBuilder.js";
+import { protectedCont, protectedBind, protectedReturn } from "./AsyncBuilder.js";
 import { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from "./Choice.js";
 import { TimeoutException } from "./SystemException.js";
-// Implemented just for type references
-export class Async {
-}
 function emptyContinuation(_x) {
     // NOP
 }
@@ -155,4 +150,3 @@ export function startWithContinuations(computation, continuation, exceptionConti
 export function startAsPromise(computation, cancellationToken) {
     return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));
 }
-export default Async;

package/AsyncBuilder.d.ts

@@ -39,21 +39,21 @@ export interface IAsyncContext<T> {
     cancelToken: CancellationToken;
     trampoline: Trampoline;
 }
-export type IAsync<T> = (x: IAsyncContext<T>) => void;
-export declare function protectedCont<T>(f: IAsync<T>): (ctx: IAsyncContext<T>) => void;
-export declare function protectedBind<T, U>(computation: IAsync<T>, binder: (x: T) => IAsync<U>): (ctx: IAsyncContext<U>) => void;
+export type Async<T> = (x: IAsyncContext<T>) => void;
+export declare function protectedCont<T>(f: Async<T>): (ctx: IAsyncContext<T>) => void;
+export declare function protectedBind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
 export declare function protectedReturn<T>(value: T): (ctx: IAsyncContext<T>) => void;
 export declare class AsyncBuilder {
-    Bind<T, U>(computation: IAsync<T>, binder: (x: T) => IAsync<U>): (ctx: IAsyncContext<U>) => void;
-    Combine<T>(computation1: IAsync<void>, computation2: IAsync<T>): (ctx: IAsyncContext<T>) => void;
-    Delay<T>(generator: () => IAsync<T>): (ctx: IAsyncContext<T>) => void;
-    For<T>(sequence: Iterable<T>, body: (x: T) => IAsync<void>): IAsync<void>;
-    Return<T>(value?: T): (ctx: IAsyncContext<T | undefined>) => void;
-    ReturnFrom<T>(computation: IAsync<T>): IAsync<T>;
-    TryFinally<T>(computation: IAsync<T>, compensation: () => void): (ctx: IAsyncContext<T>) => void;
-    TryWith<T>(computation: IAsync<T>, catchHandler: (e: any) => IAsync<T>): (ctx: IAsyncContext<T>) => void;
-    Using<T extends IDisposable, U>(resource: T, binder: (x: T) => IAsync<U>): (ctx: IAsyncContext<U>) => void;
-    While(guard: () => boolean, computation: IAsync<void>): IAsync<void>;
+    Bind<T, U>(computation: Async<T>, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
+    Combine<T>(computation1: Async<void>, computation2: Async<T>): (ctx: IAsyncContext<T>) => void;
+    Delay<T>(generator: () => Async<T>): (ctx: IAsyncContext<T>) => void;
+    For<T>(sequence: Iterable<T>, body: (x: T) => Async<void>): Async<void>;
+    Return<T>(value: T): (ctx: IAsyncContext<T>) => void;
+    ReturnFrom<T>(computation: Async<T>): Async<T>;
+    TryFinally<T>(computation: Async<T>, compensation: () => void): (ctx: IAsyncContext<T>) => void;
+    TryWith<T>(computation: Async<T>, catchHandler: (e: any) => Async<T>): (ctx: IAsyncContext<T>) => void;
+    Using<T extends IDisposable, U>(resource: T, binder: (x: T) => Async<U>): (ctx: IAsyncContext<U>) => void;
+    While(guard: () => boolean, computation: Async<void>): Async<void>;
     Zero(): (ctx: IAsyncContext<void>) => void;
 }
 export declare const singleton: AsyncBuilder;

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 1.6.0 - 2024-10-02
+
+### Removed
+
+* Remove `Async` (from `Async.ts`) class (by @MangelMaxime)
+
+### Changed
+
+* Renamed `IAsync` to `Async` in `AsyncBuilder.ts` (#3906) (by @ncave)
+
+## 1.5.0 - 2024-09-19
+
+### Added
+
+* [JS/TS] Add support for `OrdinalIgnoreCase` overload for `String.EndsWith` (#3892) (by @goswinr)
+* [JS/TS] Add `uri.Port`, `uri.IsDefaultPort` (by @MangelMaxime)
+
+### Fixed
+
+* [JS/TS] Fix escaping of `{` and `}` in FormattableString (#3890) (by @roboz0r)
+* [JS/TS] Fix `uri.Host` to return the host name without the port (by @MangelMaxime)
+* [JS/TS] Fix TypeScript compilation by resolving type of `jsOptions` (#3894) (by @ManngelMaxime)
+
 ## 1.4.3 - 2024-09-04
 
 * [JS/TS] Fixed Decimal comparisons (#3884) (by @ncave)

package/MailboxProcessor.d.ts

@@ -1,4 +1,4 @@
-import { IAsync } from "./AsyncBuilder.js";
+import { Async } from "./AsyncBuilder.js";
 import { Continuation } from "./AsyncBuilder.js";
 import { CancellationToken } from "./AsyncBuilder.js";
 declare class MailboxQueue<Msg> {
@@ -6,7 +6,7 @@ declare class MailboxQueue<Msg> {
     add(message: Msg): void;
     tryGet(): Msg | undefined;
 }
-export type MailboxBody<Msg> = (m: MailboxProcessor<Msg>) => IAsync<void>;
+export type MailboxBody<Msg> = (m: MailboxProcessor<Msg>) => Async<void>;
 export interface AsyncReplyChannel<Reply> {
     reply: (r: Reply) => void;
 }

package/String.d.ts

@@ -2,6 +2,7 @@ export declare function compare(...args: any[]): number;
 export declare function compareOrdinal(x: string, y: string): number;
 export declare function compareTo(x: string, y: string): number;
 export declare function startsWith(str: string, pattern: string, ic: number): boolean;
+export declare function endsWith(str: string, pattern: string, ic: number): boolean;
 export declare function indexOfAny(str: string, anyOf: string[], ...args: number[]): number;
 export type IPrintfFormatContinuation = (f: (x: string) => any) => any;
 export interface IPrintfFormat {
@@ -16,7 +17,6 @@ export declare function toText(arg: IPrintfFormat | string): any;
 export declare function toFail(arg: IPrintfFormat | string): any;
 export declare function fsFormat(str: string): (cont: (...args: any[]) => any) => any;
 export declare function format(str: string | object, ...args: any[]): string;
-export declare function endsWith(str: string, search: string): boolean;
 export declare function initialize(n: number, f: (i: number) => string): string;
 export declare function insert(str: string, startIndex: number, value: string): string;
 export declare function isNullOrEmpty(str: string | any): boolean;

package/String.js

@@ -58,11 +58,23 @@ export function compareTo(x, y) {
     return cmp(x, y, 0 /* StringComparison.CurrentCulture */);
 }
 export function startsWith(str, pattern, ic) {
+    if (ic === 4 /* StringComparison.Ordinal */) { // to avoid substring allocation
+        return str.startsWith(pattern);
+    }
     if (str.length >= pattern.length) {
         return cmp(str.substr(0, pattern.length), pattern, ic) === 0;
     }
     return false;
 }
+export function endsWith(str, pattern, ic) {
+    if (ic === 4 /* StringComparison.Ordinal */) { // to avoid substring allocation
+        return str.endsWith(pattern);
+    }
+    if (str.length >= pattern.length) {
+        return cmp(str.substr(str.length - pattern.length, pattern.length), pattern, ic) === 0;
+    }
+    return false;
+}
 export function indexOfAny(str, anyOf, ...args) {
     if (str == null || str === "") {
         return -1;
@@ -361,10 +373,6 @@ export function format(str, ...args) {
         return rep;
     });
 }
-export function endsWith(str, search) {
-    const idx = str.lastIndexOf(search);
-    return idx >= 0 && idx === str.length - search.length;
-}
 export function initialize(n, f) {
     if (n < 0) {
         throw new Error("String length must be non-negative");
@@ -537,7 +545,10 @@ export function fmtWith(fmts) {
     return (strs, ...args) => ({ strs, args, fmts });
 }
 export function getFormat(s) {
+    const strs = s.strs.map((value) => value.replace(/{/g, '{{').replace(/}/g, '}}'));
     return s.fmts
-        ? s.strs.reduce((acc, newPart, index) => acc + `{${String(index - 1) + s.fmts[index - 1]}}` + newPart)
-        : s.strs.reduce((acc, newPart, index) => acc + `{${index - 1}}` + newPart);
+        ? strs
+            .reduce((acc, newPart, index) => acc + `{${String(index - 1) + s.fmts[index - 1]}}` + newPart)
+        : strs
+            .reduce((acc, newPart, index) => acc + `{${index - 1}}` + newPart);
 }

package/Uri.d.ts

@@ -22,6 +22,8 @@ export declare class Uri {
     get host(): string;
     get absolutePath(): string;
     get query(): string;
+    get isDefaultPort(): boolean;
+    get port(): number;
     get pathAndQuery(): string;
     get fragment(): string;
     get originalString(): string;

package/Uri.js

@@ -119,7 +119,13 @@ export class Uri {
         return protocol.slice(0, protocol.length - 1);
     }
     get host() {
-        return this.asUrl().host;
+        const host = this.asUrl().host;
+        if (host.includes(":")) {
+            return host.split(":")[0];
+        }
+        else {
+            return host;
+        }
     }
     get absolutePath() {
         return this.asUrl().pathname;
@@ -127,6 +133,18 @@ export class Uri {
     get query() {
         return this.asUrl().search;
     }
+    get isDefaultPort() {
+        return this.port === 80;
+    }
+    get port() {
+        const port = this.asUrl().port;
+        if (port === "") {
+            return 80;
+        }
+        else {
+            return parseInt(port);
+        }
+    }
     get pathAndQuery() {
         const url = this.asUrl();
         return url.pathname + url.search;

package/Util.d.ts

@@ -161,7 +161,7 @@ export declare function max<T>(comparer: (x: T, y: T) => number, x: T, y: T): T;
 export declare function clamp<T>(comparer: (x: T, y: T) => number, value: T, min: T, max: T): T;
 export declare function createAtom<T>(value: T): (<Args extends [] | [T]>(...args: Args) => Args extends [] ? T : void);
 export declare function createObj(fields: Iterable<[string, any]>): any;
-export declare function jsOptions(mutator: (x: object) => void): object;
+export declare function jsOptions<T>(mutator: (x: T) => void): T;
 export declare function round(value: number, digits?: number): number;
 export declare function sign(x: number): number;
 export declare function unescapeDataString(s: string): string;

package/package.json

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