@fncts/test 0.0.1

package/data/LogLine/Style.d.ts

@@ -0,0 +1,107 @@
+import type { Fragment } from "./Fragment.js";
+export declare const enum StyleTag {
+    Primary = "Primary",
+    Default = "Default",
+    Warning = "Warning",
+    Error = "Error",
+    Info = "Info",
+    Detail = "Detail",
+    Dimmed = "Dimmed",
+    Bold = "Bold",
+    Underlined = "Underlined",
+    Ansi = "Ansi"
+}
+export interface Primary {
+    readonly _tag: StyleTag.Primary;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Primary
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare const Primary: Style;
+export interface Default {
+    readonly _tag: StyleTag.Default;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Default
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare const Default: Style;
+export interface Warning {
+    readonly _tag: StyleTag.Warning;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Warning
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare const Warning: Style;
+export interface Error {
+    readonly _tag: StyleTag.Error;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Error
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare const Error: Style;
+export interface Info {
+    readonly _tag: StyleTag.Info;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Info
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare const Info: Style;
+export interface Detail {
+    readonly _tag: StyleTag.Detail;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Detail
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare const Detail: Style;
+export interface Dimmed {
+    readonly _tag: StyleTag.Dimmed;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Dimmed
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare const Dimmed: Style;
+export interface Bold {
+    readonly _tag: StyleTag.Bold;
+    readonly fr: Fragment;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Bold
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare function Bold(fr: Fragment): Style;
+export interface Underlined {
+    readonly _tag: StyleTag.Underlined;
+    readonly fr: Fragment;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Underlined
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare function Underlined(fr: Fragment): Style;
+export interface Ansi {
+    readonly _tag: StyleTag.Ansi;
+    readonly fr: Fragment;
+    readonly ansiColor: string;
+}
+/**
+ * @tsplus static fncts.test.data.StyleOps Ansi
+ * @tsplus location "@fncts/test/data/LogLine/Style"
+ */
+export declare function Ansi(fr: Fragment, ansiColor: string): Style;
+/**
+ * @tsplus type fncts.test.data.StyleOps
+ */
+export declare type Style = Primary | Default | Warning | Error | Info | Detail | Dimmed | Bold | Underlined | Ansi;
+/**
+ * @tsplus type fncts.test.data.StyleOps
+ */
+export interface StyleOps {
+}
+export declare const Style: StyleOps;

package/data/LogLine/api.d.ts

@@ -0,0 +1,11 @@
+import { Fragment } from "./Fragment.js";
+export declare function info(s: string): Fragment;
+export declare function error(s: string): Fragment;
+export declare function warn(s: string): Fragment;
+export declare function primary(s: string): Fragment;
+export declare function detail(s: string): Fragment;
+export declare function fr(s: string): Fragment;
+export declare function dim(s: string): Fragment;
+export declare function bold(s: string): Fragment;
+export declare function underlined(s: string): Fragment;
+export declare const sp: Fragment;

package/data/LogLine.d.ts

@@ -0,0 +1,2 @@
+export * from "./LogLine/api.js";
+export * from "./LogLine/Style.js";

package/data/Render/api.d.ts

@@ -0,0 +1,13 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { RenderParam } from "../RenderParam.js";
+import type { Render } from "./definition.js";
+/**
+ * @tsplus static fncts.test.data.RenderOps fn
+ * @tsplus location "@fncts/test/data/Render/api"
+ */
+export declare function fn(name: string, paramLists: Conc<Conc<RenderParam>>): Render;
+/**
+ * @tsplus static fncts.test.data.RenderOps infix
+ * @tsplus location "@fncts/test/data/Render/api"
+ */
+export declare function infix(left: RenderParam, op: string, right: RenderParam): Render;

package/data/Render/definition.d.ts

@@ -0,0 +1,31 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { RenderParam } from "../RenderParam.js";
+export declare const enum RenderTag {
+    Function = "Function",
+    Infix = "Infix"
+}
+export declare class RenderFunction {
+    readonly name: string;
+    readonly paramLists: Conc<Conc<RenderParam>>;
+    readonly _tag = RenderTag.Function;
+    constructor(name: string, paramLists: Conc<Conc<RenderParam>>);
+    get rendered(): string;
+}
+export declare class RenderInfix {
+    readonly left: RenderParam;
+    readonly op: string;
+    readonly right: RenderParam;
+    readonly _tag = RenderTag.Infix;
+    constructor(left: RenderParam, op: string, right: RenderParam);
+    get rendered(): string;
+}
+/**
+ * @tsplus type fncts.test.data.Render
+ */
+export declare type Render = RenderFunction | RenderInfix;
+/**
+ * @tsplus type fncts.test.data.RenderOps
+ */
+export interface RenderOps {
+}
+export declare const Render: RenderOps;

package/data/Render.d.ts

@@ -0,0 +1,2 @@
+export * from "./Render/api.js";
+export * from "./Render/definition.js";

package/data/RenderParam/api.d.ts

@@ -0,0 +1,13 @@
+import type { AssertionIO } from "../../control/AssertionIO/definition.js";
+import type { RenderParam } from "./definition.js";
+/**
+ * @tsplus static fncts.test.data.RenderParamOps __call
+ * @tsplus location "@fncts/test/data/RenderParam/api"
+ */
+export declare function param<A>(assertion: AssertionIO<A>): RenderParam;
+export declare function param<A>(value: A): RenderParam;
+/**
+ * @tsplus getter fncts.test.data.RenderParam rendered
+ * @tsplus location "@fncts/test/data/RenderParam/api"
+ */
+export declare function rendered<A>(self: RenderParam<A>): string;

package/data/RenderParam/definition.d.ts

@@ -0,0 +1,25 @@
+import type { AssertionIO } from "../../control/AssertionIO/definition.js";
+export declare const enum RenderParamTag {
+    AssertionIO = "AssertionIO",
+    Value = "Value"
+}
+export declare class RenderAssertionIO<A> {
+    readonly assertion: AssertionIO<A>;
+    readonly _tag = RenderParamTag.AssertionIO;
+    constructor(assertion: AssertionIO<A>);
+}
+export declare class RenderValue<A> {
+    readonly value: A;
+    readonly _tag = RenderParamTag.Value;
+    constructor(value: A);
+}
+/**
+ * @tsplus type fncts.test.data.RenderParam
+ */
+export declare type RenderParam<A = any> = RenderAssertionIO<A> | RenderValue<A>;
+/**
+ * @tsplus type fncts.test.data.RenderParamOps
+ */
+export interface RenderParamOps {
+}
+export declare const RenderParam: RenderParamOps;

package/data/RenderParam.d.ts

@@ -0,0 +1,2 @@
+export * from "./RenderParam/api.js";
+export * from "./RenderParam/definition.js";

package/data/Summary.d.ts

@@ -0,0 +1,8 @@
+export declare class Summary {
+    readonly success: number;
+    readonly fail: number;
+    readonly ignore: number;
+    readonly summary: string;
+    constructor(success: number, fail: number, ignore: number, summary: string);
+    total: number;
+}

package/data/TestAnnotation/api.d.ts

@@ -0,0 +1,41 @@
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Ref } from "@fncts/io/Ref";
+import { TestAnnotation } from "./definition.js";
+export declare const IgnoredTag: import("@fncts/base/data/Tag.js").Tag<number>;
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Ignored
+ * @tsplus location "@fncts/test/data/TestAnnotation/api"
+ */
+export declare const Ignored: TestAnnotation<number>;
+export declare const RepeatedTag: import("@fncts/base/data/Tag.js").Tag<number>;
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Repeated
+ * @tsplus location "@fncts/test/data/TestAnnotation/api"
+ */
+export declare const Repeated: TestAnnotation<number>;
+export declare const RetriedTag: import("@fncts/base/data/Tag.js").Tag<number>;
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Retried
+ * @tsplus location "@fncts/test/data/TestAnnotation/api"
+ */
+export declare const Retried: TestAnnotation<number>;
+export declare const TaggedTag: import("@fncts/base/data/Tag.js").Tag<import("@fncts/base/collection/immutable/HashSet.js").HashSet<string>>;
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Tagged
+ * @tsplus location "@fncts/test/data/TestAnnotation/api"
+ */
+export declare const Tagged: TestAnnotation<import("@fncts/base/collection/immutable/HashSet.js").HashSet<string>>;
+export declare const TimingTag: import("@fncts/base/data/Tag.js").Tag<number>;
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Timing
+ * @tsplus location "@fncts/test/data/TestAnnotation/api"
+ */
+export declare const Timing: TestAnnotation<number>;
+export declare const FibersTag: import("@fncts/base/data/Tag.js").Tag<import("@fncts/base/data/Either.js").Either<number, import("@fncts/base/collection/immutable/Conc.js").Conc<import("@fncts/io/Ref.js").Ref<import("@fncts/base/collection/immutable/HashSet.js").HashSet<import("@fncts/io/Fiber.js").Fiber.Runtime<any, any>>>>>>;
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Fibers
+ * @tsplus location "@fncts/test/data/TestAnnotation/api"
+ */
+export declare const Fibers: TestAnnotation<import("@fncts/base/data/Either.js").Either<number, import("@fncts/base/collection/immutable/Conc.js").Conc<import("@fncts/io/Ref.js").Ref<import("@fncts/base/collection/immutable/HashSet.js").HashSet<import("@fncts/io/Fiber.js").Fiber.Runtime<any, any>>>>>>;

package/data/TestAnnotation/definition.d.ts

@@ -0,0 +1,20 @@
+import { Hashable, Equatable } from "@fncts/base/typeclass";
+import { Tag } from "@fncts/base/data/Tag";
+export declare const TestAnnotationTypeId: unique symbol;
+export declare type TestAnnotationTypeId = typeof TestAnnotationTypeId;
+/**
+ * @tsplus type fncts.test.TestAnnotation
+ * @tsplus companion fncts.test.TestAnnotationOps
+ */
+export declare class TestAnnotation<V> implements Hashable, Equatable {
+    readonly tag: Tag<V>;
+    readonly identifier: string;
+    readonly initial: V;
+    readonly combine: (v1: V, v2: V) => V;
+    readonly _typeId: TestAnnotationTypeId;
+    readonly _V: () => V;
+    constructor(tag: Tag<V>, identifier: string, initial: V, combine: (v1: V, v2: V) => V);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+export declare function isTestAnnotation(u: unknown): u is TestAnnotation<unknown>;

package/data/TestAnnotation.d.ts

@@ -0,0 +1,2 @@
+export * from "./TestAnnotation/api.js";
+export * from "./TestAnnotation/definition.js";

package/data/TestAnnotationMap.d.ts

@@ -0,0 +1,12 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import type { TestAnnotation } from "./TestAnnotation.js";
+export declare class TestAnnotationMap {
+    private readonly map;
+    constructor(map: HashMap<TestAnnotation<any>, any>);
+    combine(that: TestAnnotationMap): TestAnnotationMap;
+    get<V>(key: TestAnnotation<V>): V;
+    private overwrite;
+    private update;
+    annotate<V>(key: TestAnnotation<V>, value: V): TestAnnotationMap;
+    static empty: TestAnnotationMap;
+}

package/data/TestArgs/definition.d.ts

@@ -0,0 +1,7 @@
+import { Maybe } from "@fncts/base/data/Maybe";
+export declare class TestArgs {
+    readonly testSearchTerms: ReadonlyArray<string>;
+    readonly tagSearchTerms: ReadonlyArray<string>;
+    readonly testTaskPolicy: Maybe<string>;
+    constructor(testSearchTerms: ReadonlyArray<string>, tagSearchTerms: ReadonlyArray<string>, testTaskPolicy: Maybe<string>);
+}

package/data/TestArgs.d.ts

@@ -0,0 +1 @@
+export * from "./TestArgs/definition.js";

package/data/TestConfig.d.ts

@@ -0,0 +1,42 @@
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+/**
+ * @tsplus type fncts.test.data.TestConfig
+ * @tsplus companion fncts.test.data.TestConfigOps
+ */
+export declare abstract class TestConfig {
+    abstract readonly repeats: number;
+    abstract readonly retries: number;
+    abstract readonly samples: number;
+    abstract readonly shrinks: number;
+}
+/**
+ * @tsplus static fncts.test.data.TestConfigOps Tag
+ * @tsplus location "@fncts/test/data/TestConfig"
+ */
+export declare const TestConfigTag: import("@fncts/base/data/Tag").Tag<TestConfig>;
+/**
+ * @tsplus static fncts.test.data.TestConfigOps Live
+ * @tsplus location "@fncts/test/data/TestConfig"
+ */
+export declare function live(_: TestConfig): Layer<unknown, never, Has<TestConfig>>;
+/**
+ * @tsplus static fncts.test.data.TestConfigOps repeats
+ * @tsplus location "@fncts/test/data/TestConfig"
+ */
+export declare const repeats: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;
+/**
+ * @tsplus static fncts.test.data.TestConfigOps retries
+ * @tsplus location "@fncts/test/data/TestConfig"
+ */
+export declare const retries: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;
+/**
+ * @tsplus static fncts.test.data.TestConfigOps samples
+ * @tsplus location "@fncts/test/data/TestConfig"
+ */
+export declare const samples: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;
+/**
+ * @tsplus static fncts.test.data.TestConfigOps shrinks
+ * @tsplus location "@fncts/test/data/TestConfig"
+ */
+export declare const shrinks: import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestConfig>, never, number>;

package/data/TestFailure.d.ts

@@ -0,0 +1,46 @@
+import { Cause } from "@fncts/base/data/Cause";
+import type { TestResult } from "./FailureDetails.js";
+export declare const enum TestFailureTag {
+    AssertionFailure = "AssertionFailure",
+    RuntimeFailure = "RuntimeFailure"
+}
+export declare class AssertionFailure {
+    readonly result: TestResult;
+    readonly _tag = TestFailureTag.AssertionFailure;
+    constructor(result: TestResult);
+}
+export declare class RuntimeFailure<E> {
+    readonly cause: Cause<E>;
+    readonly _tag = TestFailureTag.RuntimeFailure;
+    constructor(cause: Cause<E>);
+}
+/**
+ * @tsplus type fncts.test.data.TestFailure
+ */
+export declare type TestFailure<E> = AssertionFailure | RuntimeFailure<E>;
+/**
+ * @tsplus type fncts.test.data.TestFailureOps
+ */
+export interface TestFailureOps {
+}
+export declare const TestFailure: TestFailureOps;
+/**
+ * @tsplus static fncts.test.data.TestFailureOps assertion
+ * @tsplus location "@fncts/test/data/TestFailure"
+ */
+export declare function assertion(result: TestResult): TestFailure<never>;
+/**
+ * @tsplus static fncts.test.data.TestFailureOps halt
+ * @tsplus location "@fncts/test/data/TestFailure"
+ */
+export declare function halt(defect: unknown): TestFailure<never>;
+/**
+ * @tsplus static fncts.test.data.TestFailureOps fail
+ * @tsplus location "@fncts/test/data/TestFailure"
+ */
+export declare function fail<E>(e: E): TestFailure<E>;
+/**
+ * @tsplus static fncts.test.data.TestFailureOps failCause
+ * @tsplus location "@fncts/test/data/TestFailure"
+ */
+export declare function failCause<E>(cause: Cause<E>): TestFailure<E>;

package/data/TestSuccess.d.ts

@@ -0,0 +1,33 @@
+import type { FreeBooleanAlgebra } from "./FreeBooleanAlgebra.js";
+export declare const enum TestSuccessTag {
+    Succeeded = "Succeeded",
+    Ignored = "Ignored"
+}
+export declare class Succeeded {
+    readonly result: FreeBooleanAlgebra<void>;
+    readonly _tag = TestSuccessTag.Succeeded;
+    constructor(result: FreeBooleanAlgebra<void>);
+}
+export declare class Ignored {
+    readonly _tag = TestSuccessTag.Ignored;
+}
+/**
+ * @tsplus type fncts.test.TestSuccess
+ */
+export declare type TestSuccess = Succeeded | Ignored;
+/**
+ * @tsplus type fncts.test.TestSuccessOps
+ */
+export interface TestSuccessOps {
+}
+export declare const TestSuccess: TestSuccessOps;
+/**
+ * @tsplus static fncts.test.TestSuccessOps Succeeded
+ * @tsplus location "@fncts/test/data/TestSuccess"
+ */
+export declare function succeeded(result: FreeBooleanAlgebra<void>): TestSuccess;
+/**
+ * @tsplus static fncts.test.TestSuccessOps Ignored
+ * @tsplus location "@fncts/test/data/TestSuccess"
+ */
+export declare const ignored: Ignored;

package/data/TestTimeoutException.d.ts

@@ -0,0 +1,3 @@
+export declare class TestTimeoutException extends Error {
+    constructor(message: string);
+}

package/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@fncts/test",
+  "version": "0.0.1",
+  "dependencies": {
+    "@fncts/base": "0.0.1",
+    "@fncts/io": "0.0.1",
+    "@fncts/typelevel": "0.0.1"
+  },
+  "exports": {
+    "./*": {
+      "import": "./_mjs/*",
+      "require": "./_cjs/*"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/util/math.d.ts

@@ -0,0 +1,130 @@
+import { IO, URIO } from "@fncts/io/IO";
+/** @internal */
+export declare const MIN_VALUE_32: number;
+/** @internal */
+export declare const MAX_VALUE_32: number;
+/** @internal */
+export declare const EPSILON_32: number;
+export declare function safeFloatToIndex(f: number, label: string): IO<unknown, never, number>;
+export declare function decomposeFloat(f: number): {
+    exponent: number;
+    significand: number;
+};
+export declare function floatToIndex(f: number): number;
+/** @internal */
+export declare function indexInFloatFromDecomp(exponent: number, significand: number): number;
+/**
+ * Compute the 32-bit floating point number corresponding to the provided indexes
+ *
+ * @param n - index of the float
+ *
+ * @internal
+ */
+export declare function indexToFloat(index: number): number;
+/** @internal */
+export declare type ArrayInt64 = {
+    sign: 1 | -1;
+    data: [number, number];
+};
+/** @internal */
+export declare const Zero64: ArrayInt64;
+/** @internal */
+export declare const Unit64: ArrayInt64;
+/** @internal */
+export declare function isZero64(a: ArrayInt64): boolean;
+/** @internal */
+export declare function isStrictlyNegative64(a: ArrayInt64): boolean;
+/** @internal */
+export declare function isStrictlyPositive64(a: ArrayInt64): boolean;
+/** @internal */
+export declare function isEqual64(a: ArrayInt64, b: ArrayInt64): boolean;
+/** @internal */
+export declare function isStrictlySmaller64(a: ArrayInt64, b: ArrayInt64): boolean;
+/** @internal */
+export declare function clone64(a: ArrayInt64): ArrayInt64;
+/**
+ * Substract two ArrayInt64
+ * @returns When result is zero always with sign=1
+ * @internal
+ */
+export declare function substract64(arrayIntA: ArrayInt64, arrayIntB: ArrayInt64): ArrayInt64;
+/**
+ * Negative version of an ArrayInt64
+ * @internal
+ */
+export declare function negative64(arrayIntA: ArrayInt64): ArrayInt64;
+/**
+ * Add two ArrayInt64
+ * @returns When result is zero always with sign=1
+ * @internal
+ */
+export declare function add64(arrayIntA: ArrayInt64, arrayIntB: ArrayInt64): ArrayInt64;
+/**
+ * Halve an ArrayInt64
+ * @internal
+ */
+export declare function halve64(a: ArrayInt64): ArrayInt64;
+/**
+ * Apply log2 to an ArrayInt64 (preserve sign)
+ * @internal
+ */
+export declare function logLike64(a: ArrayInt64): ArrayInt64;
+/**
+ * Decompose a 64-bit floating point number into a significand and exponent
+ * such that:
+ * - significand over 53 bits including sign (also referred as fraction)
+ * - exponent over 11 bits including sign
+ * - whenever there are multiple possibilities we take the one having the highest significand (in abs)
+ * - Number.MAX_VALUE = 2**1023    * (1 + (2**52-1)/2**52)
+ *                    = 2**1023    * (2 - Number.EPSILON)
+ * - Number.MIN_VALUE = 2**(-1022) * 2**(-52)
+ * - Number.EPSILON   = 2**(-52)
+ *
+ * @param d - 64-bit floating point number to be decomposed into (significand, exponent)
+ *
+ * @internal
+ */
+export declare function decomposeDouble(d: number): {
+    exponent: number;
+    significand: number;
+};
+/**
+ * Compute the index of d relative to other available 64-bit floating point numbers
+ * Rq: Produces negative indexes for negative doubles
+ *
+ * @param d - 64-bit floating point number, anything except NaN
+ *
+ * @internal
+ */
+export declare function doubleToIndex(d: number): ArrayInt64;
+/**
+ * Compute the 64-bit floating point number corresponding to the provided indexes
+ *
+ * @param n - index of the double
+ *
+ * @internal
+ */
+export declare function indexToDouble(index: ArrayInt64): number;
+/**
+ * Same as {@link doubleToIndex} except it throws in case of invalid double
+ *
+ * @internal
+ */
+export declare function safeDoubleToIndex(d: number, label: string): IO<unknown, never, ArrayInt64>;
+export declare function nextUp(x: number): number;
+export declare function nextAfter(x: number, y: number): number;
+export declare function computeBiasedRanges(min: ArrayInt64, max: ArrayInt64, biasedRanges?: {
+    min: ArrayInt64;
+    max: ArrayInt64;
+}[]): {
+    min: ArrayInt64;
+    max: ArrayInt64;
+}[];
+export declare function computeArrayInt64GenerateRange(min: ArrayInt64, max: ArrayInt64, biasFactor: number | undefined, biasedRanges: {
+    min: ArrayInt64;
+    max: ArrayInt64;
+}[] | undefined): URIO<unknown, {
+    min: ArrayInt64;
+    max: ArrayInt64;
+}>;
+export declare function clamp(n: number, min: number, max: number): number;