@fncts/test 0.0.1

package/control/TestRunner.d.ts

@@ -0,0 +1,18 @@
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+import { URIO } from "@fncts/io/IO";
+import type { RuntimeConfig } from "@fncts/io/RuntimeConfig";
+import type { Annotations } from "@fncts/test/control/Annotations";
+import type { TestReporter } from "@fncts/test/control/DefaultTestReporter/render";
+import type { Spec } from "@fncts/test/control/Spec";
+import type { TestExecutor } from "@fncts/test/control/TestExecutor";
+import type { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
+import { TestLogger } from "@fncts/test/control/TestLogger";
+export declare class TestRunner<R, E> {
+    readonly executor: TestExecutor<R>;
+    readonly runtimeConfig: RuntimeConfig;
+    readonly reporter: TestReporter<E>;
+    readonly bootstrap: Layer<unknown, never, Has<TestLogger>>;
+    constructor(executor: TestExecutor<R>, runtimeConfig?: RuntimeConfig, reporter?: TestReporter<E>, bootstrap?: Layer<unknown, never, Has<TestLogger>>);
+    run(spec: Spec<R & Has<Annotations>, E>): URIO<Has<TestLogger>, ExecutedSpec<E>>;
+}

package/data/AssertionData.d.ts

@@ -0,0 +1,24 @@
+import type { Assertion } from "../control/Assertion/definition.js";
+import { AssertionValue } from "./AssertionValue.js";
+import { FreeBooleanAlgebra } from "./FreeBooleanAlgebra.js";
+export declare const AssertionDataTypeId: unique symbol;
+export declare type AssertionDataTypeId = typeof AssertionDataTypeId;
+/**
+ * @tsplus type fncts.test.data.AssertionData
+ */
+export declare class AssertionData<A> {
+    readonly value: A;
+    readonly assertion: Assertion<A>;
+    readonly _typeId: AssertionDataTypeId;
+    constructor(value: A, assertion: Assertion<A>);
+}
+/**
+ * @tsplus getter fncts.test.data.AssertionData asSuccess
+ * @tsplus location "@fncts/test/data/AssertionData"
+ */
+export declare function asSuccess<A>(self: AssertionData<A>): FreeBooleanAlgebra<AssertionValue<A>>;
+/**
+ * @tsplus getter fncts.test.data.AssertionData asFailure
+ * @tsplus location "@fncts/test/data/AssertionData"
+ */
+export declare function asFailure<A>(self: AssertionData<A>): FreeBooleanAlgebra<AssertionValue<A>>;

package/data/AssertionResult.d.ts

@@ -0,0 +1,23 @@
+import { Maybe } from "@fncts/base/data/Maybe";
+import type { FailureDetails } from "./FailureDetails.js";
+import type { GenFailureDetails } from "./GenFailureDetails.js";
+export declare class FailureDetailsResult {
+    readonly failureDetails: FailureDetails;
+    readonly genFailureDetails: Maybe<GenFailureDetails>;
+    constructor(failureDetails: FailureDetails, genFailureDetails?: Maybe<GenFailureDetails>);
+}
+/**
+ * @tsplus type fncts.test.data.AssertionResult
+ */
+export declare type AssertionResult = FailureDetailsResult;
+/**
+ * @tsplus type fncts.test.data.AssertionResultOps
+ */
+export interface AssertionResultOps {
+}
+export declare const AssertionResult: AssertionResultOps;
+/**
+ * @tsplus static fncts.test.data.AssertionResultOps FailureDetailsResult
+ * @tsplus location "@fncts/test/data/AssertionResult"
+ */
+export declare function failureDetailsResult(failureDetails: FailureDetails, genFailureDetails?: Maybe<GenFailureDetails>): AssertionResult;

package/data/AssertionValue/api.d.ts

@@ -0,0 +1,27 @@
+import { Maybe } from "@fncts/base/data/Maybe";
+import { AssertionValue } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue label
+ * @tsplus location "@fncts/test/data/AssertionValue/api"
+ */
+export declare function label<A>(self: AssertionValue<A>, string: string): AssertionValue<A>;
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue isSameAssertionAs
+ * @tsplus location "@fncts/test/data/AssertionValue/api"
+ */
+export declare function isSameAssertionAs<A>(self: AssertionValue<A>, that: AssertionValue<A>): boolean;
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue showValue
+ * @tsplus location "@fncts/test/data/AssertionValue/api"
+ */
+export declare function showValue<A>(self: AssertionValue<A>, offset?: number): string;
+/**
+ * @tsplus getter fncts.test.data.AssertionValue printAssertion
+ * @tsplus location "@fncts/test/data/AssertionValue/api"
+ */
+export declare function printAssertion<A>(self: AssertionValue<A>): string;
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue withContext
+ * @tsplus location "@fncts/test/data/AssertionValue/api"
+ */
+export declare function withContext<A>(self: AssertionValue<A>, expr: Maybe<string>, sourceLocation: Maybe<string>): AssertionValue<A>;

package/data/AssertionValue/definition.d.ts

@@ -0,0 +1,19 @@
+import { LazyValue } from "@fncts/base/control/LazyValue";
+import { Maybe } from "@fncts/base/data/Maybe";
+import type { AssertionIO } from "../../control/AssertionIO/definition.js";
+import type { FreeBooleanAlgebra } from "../FreeBooleanAlgebra.js";
+export declare const AssertionValueTypeId: unique symbol;
+export declare type AssertionValueTypeId = typeof AssertionValueTypeId;
+/**
+ * @tsplus type fncts.test.data.AssertionValue
+ * @tsplus companion fncts.test.data.AssertionValueOps
+ */
+export declare class AssertionValue<A> {
+    readonly assertion: LazyValue<AssertionIO<A>>;
+    readonly value: A;
+    readonly result: LazyValue<FreeBooleanAlgebra<AssertionValue<A>>>;
+    readonly expression: Maybe<string>;
+    readonly sourceLocation: Maybe<string>;
+    readonly _typeId: AssertionValueTypeId;
+    constructor(assertion: LazyValue<AssertionIO<A>>, value: A, result: LazyValue<FreeBooleanAlgebra<AssertionValue<A>>>, expression?: Maybe<string>, sourceLocation?: Maybe<string>);
+}

package/data/AssertionValue.d.ts

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

package/data/ExecutedSpec/api.d.ts

@@ -0,0 +1,47 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { TestAnnotationMap } from "../TestAnnotationMap.js";
+import type { TestFailure } from "../TestFailure.js";
+import type { TestSuccess } from "../TestSuccess.js";
+import type { SpecCase } from "./definition.js";
+import { ExecutedSpec } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpec fold
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function fold_<E, Z>(self: ExecutedSpec<E>, f: (_: SpecCase<E, Z>) => Z): Z;
+/**
+ * @tsplus static fncts.test.data.ExecutedSpecOps labeled
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function labeled<E>(spec: ExecutedSpec<E>, label: string): ExecutedSpec<E>;
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpecCase map
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function mapSpecCase_<E, A, B>(self: SpecCase<E, A>, f: (a: A) => B): SpecCase<E, B>;
+/**
+ * @tsplus static fncts.test.data.ExecutedSpecOps multiple
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function multiple<E>(specs: Conc<ExecutedSpec<E>>): ExecutedSpec<E>;
+/**
+ * @tsplus static fncts.test.data.ExecutedSpecOps test
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function test<E>(test: Either<TestFailure<E>, TestSuccess>, annotations: TestAnnotationMap): ExecutedSpec<E>;
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpec transform
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function transform_<E, E1>(self: ExecutedSpec<E>, f: (_: SpecCase<E, ExecutedSpec<E1>>) => SpecCase<E1, ExecutedSpec<E1>>): ExecutedSpec<E1>;
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpec exists
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function exists_<E>(self: ExecutedSpec<E>, f: (_: SpecCase<E, boolean>) => boolean): boolean;
+/**
+ * @tsplus getter fncts.test.data.ExecutedSpec size
+ * @tsplus location "@fncts/test/data/ExecutedSpec/api"
+ */
+export declare function size<E>(self: ExecutedSpec<E>): number;

package/data/ExecutedSpec/definition.d.ts

@@ -0,0 +1,39 @@
+import { Either } from "@fncts/base/data/Either/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { TestAnnotationMap } from "../TestAnnotationMap.js";
+import type { TestFailure } from "../TestFailure.js";
+import type { TestSuccess } from "../TestSuccess.js";
+export declare const enum ExecutedSpecCaseTag {
+    Test = "Test",
+    Labeled = "Labeled",
+    Multiple = "Multiple"
+}
+/**
+ * @tsplus type fncts.test.data.ExecutedSpec
+ * @tsplus companion fncts.test.data.ExecutedSpecOps
+ */
+export declare class ExecutedSpec<E> {
+    readonly caseValue: SpecCase<E, ExecutedSpec<E>>;
+    constructor(caseValue: SpecCase<E, ExecutedSpec<E>>);
+}
+export declare class TestCase<E> {
+    readonly test: Either<TestFailure<E>, TestSuccess>;
+    readonly annotations: TestAnnotationMap;
+    readonly _tag = ExecutedSpecCaseTag.Test;
+    constructor(test: Either<TestFailure<E>, TestSuccess>, annotations: TestAnnotationMap);
+}
+export declare class LabeledCase<A> {
+    readonly label: string;
+    readonly spec: A;
+    readonly _tag = ExecutedSpecCaseTag.Labeled;
+    constructor(label: string, spec: A);
+}
+export declare class MultipleCase<A> {
+    readonly specs: Conc<A>;
+    readonly _tag = ExecutedSpecCaseTag.Multiple;
+    constructor(specs: Conc<A>);
+}
+/**
+ * @tsplus type fncts.test.data.ExecutedSpecCase
+ */
+export declare type SpecCase<E, A> = TestCase<E> | LabeledCase<A> | MultipleCase<A>;

package/data/ExecutedSpec.d.ts

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

package/data/ExecutionResult.d.ts

@@ -0,0 +1,59 @@
+import { List } from "@fncts/base/collection/immutable/List";
+import type { Line } from "./LogLine/Line.js";
+import type { TestAnnotationMap } from "./TestAnnotationMap.js";
+export interface Failed {
+    readonly _tag: "Failed";
+}
+export declare const Failed: Failed;
+export interface Passed {
+    readonly _tag: "Passed";
+}
+export declare const Passed: Passed;
+export interface Ignored {
+    readonly _tag: "Ignored";
+}
+export declare const Ignored: Ignored;
+export declare type Status = Failed | Passed | Ignored;
+interface Test {
+    readonly _tag: "Test";
+}
+export declare const Test: ResultType;
+export interface Suite {
+    readonly _tag: "Suite";
+}
+export declare const Suite: ResultType;
+export interface Other {
+    readonly _tag: "Other";
+}
+export declare const Other: ResultType;
+export declare type ResultType = Test | Suite | Other;
+/**
+ * @tsplus type fncts.test.ExecutionResult
+ */
+export declare class ExecutionResult {
+    readonly resultType: ResultType;
+    readonly label: string;
+    readonly status: Status;
+    readonly offset: number;
+    readonly annotations: List<TestAnnotationMap>;
+    readonly lines: List<Line>;
+    constructor(resultType: ResultType, label: string, status: Status, offset: number, annotations: List<TestAnnotationMap>, lines: List<Line>);
+    withAnnotations(annotations: List<TestAnnotationMap>): ExecutionResult;
+}
+export declare function rendered(caseType: ResultType, label: string, status: Status, offset: number, lines: List<Line>): ExecutionResult;
+/**
+ * @tsplus operator fncts.test.ExecutionResult &&
+ * @tsplus location "@fncts/test/data/ExecutionResult"
+ */
+export declare function and_(self: ExecutionResult, that: ExecutionResult): ExecutionResult;
+/**
+ * @tsplus operator fncts.test.ExecutionResult ||
+ * @tsplus location "@fncts/test/data/ExecutionResult"
+ */
+export declare function or_(self: ExecutionResult, that: ExecutionResult): ExecutionResult;
+/**
+ * @tsplus getter fncts.test.ExecutionResult invert
+ * @tsplus location "@fncts/test/data/ExecutionResult"
+ */
+export declare function invert(self: ExecutionResult): ExecutionResult;
+export {};

package/data/FailureDetails.d.ts

@@ -0,0 +1,15 @@
+import { Cons } from "@fncts/base/collection/immutable/List";
+import { Maybe } from "@fncts/base/data/Maybe";
+import type { FailureDetailsResult } from "./AssertionResult.js";
+import type { AssertionValue } from "./AssertionValue.js";
+import type { FreeBooleanAlgebra } from "./FreeBooleanAlgebra.js";
+import type { GenFailureDetails } from "./GenFailureDetails.js";
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebra
+ */
+export declare type TestResult = FreeBooleanAlgebra<FailureDetailsResult>;
+export declare class FailureDetails {
+    readonly assertion: Cons<AssertionValue<any>>;
+    readonly gen: Maybe<GenFailureDetails<any>>;
+    constructor(assertion: Cons<AssertionValue<any>>, gen: Maybe<GenFailureDetails<any>>);
+}

package/data/FreeBooleanAlgebra/api.d.ts

@@ -0,0 +1,81 @@
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Eval } from "@fncts/base/control/Eval";
+import { FreeBooleanAlgebra } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra and
+ * @tsplus operator fncts.test.FreeBooleanAlgebra &&
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function and_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra flatMap
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function flatMap_<A, B>(self: FreeBooleanAlgebra<A>, f: (a: A) => FreeBooleanAlgebra<B>): FreeBooleanAlgebra<B>;
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraOps failure
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function failure<A>(a: A): FreeBooleanAlgebra<A>;
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra failures
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function failures<A>(self: FreeBooleanAlgebra<A>): Maybe<FreeBooleanAlgebra<A>>;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra foldEval
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function foldEval_<A, B>(self: FreeBooleanAlgebra<A>, cases: {
+    Value: (value: A) => B;
+    And: (left: B, right: B) => B;
+    Or: (left: B, right: B) => B;
+    Not: (value: B) => B;
+}): Eval<B>;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra fold
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function fold_<A, B>(self: FreeBooleanAlgebra<A>, cases: {
+    Value: (value: A) => B;
+    And: (left: B, right: B) => B;
+    Or: (left: B, right: B) => B;
+    Not: (value: B) => B;
+}): B;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra iff
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function iff_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra implies
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function implies_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra isFailure
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function isFailure<A>(self: FreeBooleanAlgebra<A>): boolean;
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra isSuccess
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function isSuccess<A>(self: FreeBooleanAlgebra<A>): boolean;
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra invert
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function not<A>(self: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra or
+ * @tsplus operator fncts.test.FreeBooleanAlgebra ||
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function or_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A>;
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraOps success
+ * @tsplus location "@fncts/test/data/FreeBooleanAlgebra/api"
+ */
+export declare function success<A>(a: A): FreeBooleanAlgebra<A>;

package/data/FreeBooleanAlgebra/definition.d.ts

@@ -0,0 +1,38 @@
+export declare const enum FreeBooleanAlgebraTag {
+    Value = "Value",
+    And = "And",
+    Or = "Or",
+    Not = "Not"
+}
+export declare class Value<A> {
+    readonly value: A;
+    readonly _tag = FreeBooleanAlgebraTag.Value;
+    constructor(value: A);
+}
+export declare class And<A> {
+    readonly left: FreeBooleanAlgebra<A>;
+    readonly right: FreeBooleanAlgebra<A>;
+    readonly _tag = FreeBooleanAlgebraTag.And;
+    constructor(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>);
+}
+export declare class Or<A> {
+    readonly left: FreeBooleanAlgebra<A>;
+    readonly right: FreeBooleanAlgebra<A>;
+    readonly _tag = FreeBooleanAlgebraTag.Or;
+    constructor(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>);
+}
+export declare class Not<A> {
+    readonly result: FreeBooleanAlgebra<A>;
+    readonly _tag = FreeBooleanAlgebraTag.Not;
+    constructor(result: FreeBooleanAlgebra<A>);
+}
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebra
+ */
+export declare type FreeBooleanAlgebra<A> = Value<A> | And<A> | Or<A> | Not<A>;
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebraOps
+ */
+export interface FreeBooleanAlgebraOps {
+}
+export declare const FreeBooleanAlgebra: FreeBooleanAlgebraOps;

package/data/FreeBooleanAlgebra.d.ts

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

package/data/GenFailureDetails.d.ts

@@ -0,0 +1,6 @@
+export declare class GenFailureDetails<A = any> {
+    readonly initialInput: A;
+    readonly shrunkenInput: A;
+    readonly iterations: number;
+    constructor(initialInput: A, shrunkenInput: A, iterations: number);
+}

package/data/LogLine/Fragment.d.ts

@@ -0,0 +1,46 @@
+import { Line } from "./Line.js";
+import { Style } from "./Style.js";
+/**
+ * @tsplus type fncts.test.data.Fragment
+ * @tsplus companion fncts.test.data.FragmentOps
+ */
+export declare class Fragment {
+    readonly text: string;
+    readonly style: Style;
+    constructor(text: string, style?: Style);
+}
+/**
+ * @tsplus static fncts.test.data.FragmentOps __call
+ * @tsplus location "@fncts/test/data/LogLine/Fragment"
+ */
+export declare function makeFragment(text: string, style?: Style): Fragment;
+/**
+ * @tsplus operator fncts.test.data.Fragment +
+ * @tsplus location "@fncts/test/data/LogLine/Fragment"
+ */
+export declare function appendTo(line: Line, self: Fragment): Line;
+/**
+ * @tsplus operator fncts.test.data.Fragment +
+ * @tsplus location "@fncts/test/data/LogLine/Fragment"
+ */
+export declare function prependTo(self: Fragment, line: Line): Line;
+/**
+ * @tsplus operator fncts.test.data.Fragment +
+ * @tsplus location "@fncts/test/data/LogLine/Fragment"
+ */
+export declare function append(self: Fragment, that: Fragment): Line;
+/**
+ * @tsplus getter fncts.test.data.Fragment toLine
+ * @tsplus location "@fncts/test/data/LogLine/Fragment"
+ */
+export declare function toLine(self: Fragment): Line;
+/**
+ * @tsplus getter fncts.test.data.Fragment bold
+ * @tsplus location "@fncts/test/data/LogLine/Fragment"
+ */
+export declare function bold(self: Fragment): Fragment;
+/**
+ * @tsplus getter fncts.test.data.Fragment underlined
+ * @tsplus location "@fncts/test/data/LogLine/Fragment"
+ */
+export declare function underlined(self: Fragment): Fragment;

package/data/LogLine/Line.d.ts

@@ -0,0 +1,62 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { Fragment } from "./Fragment.js";
+import { Message } from "./Message.js";
+/**
+ * @tsplus type fncts.test.data.Line
+ * @tsplus companion fncts.test.data.LineOps
+ */
+export declare class Line {
+    readonly fragments: Vector<Fragment>;
+    readonly offset: number;
+    constructor(fragments?: Vector<Fragment>, offset?: number);
+}
+/**
+ * @tsplus static fncts.test.data.LineOps empty
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare const empty: Line;
+/**
+ * @tsplus static fncts.test.data.LineOps fromString
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function fromString(text: string, offset?: number): Line;
+/**
+ * @tsplus static fncts.test.data.LineOps __call
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function makeLine(fragments?: Vector<Fragment>, offset?: number): Line;
+/**
+ * @tsplus operator fncts.test.data.Line +
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function append(self: Line, that: Line): Line;
+/**
+ * @tsplus operator fncts.test.data.Line |
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function concat(self: Line, that: Line): Message;
+/**
+ * @tsplus operator fncts.test.data.Line +
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function appendTo(message: Message, self: Line): Message;
+/**
+ * @tsplus operator fncts.test.data.Line +
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function prependTo(self: Line, message: Message): Message;
+/**
+ * @tsplus fluent fncts.test.data.Line withOffset
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function withOffset(self: Line, shift: number): Line;
+/**
+ * @tsplus getter fncts.test.data.Line toMessage
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function toMessage(self: Line): Message;
+/**
+ * @tsplus getter fncts.test.data.Line optimized
+ * @tsplus location "@fncts/test/data/LogLine/Line"
+ */
+export declare function optimized(self: Line): Line;

package/data/LogLine/Message.d.ts

@@ -0,0 +1,61 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { Fragment } from "./Fragment.js";
+import { Line } from "./Line.js";
+/**
+ * @tsplus type fncts.test.data.Message
+ * @tsplus companion fncts.test.data.MessageOps
+ */
+export declare class Message {
+    readonly lines: Vector<Line>;
+    constructor(lines?: Vector<Line>);
+}
+/**
+ * @tsplus static fncts.test.data.MessageOps empty
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare const empty: Message;
+/**
+ * @tsplus static fncts.test.data.MessageOps __call
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function makeMessage(lines?: Vector<Line>): Message;
+/**
+ * @tsplus operator fncts.test.data.Message +
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function appendFragment(self: Message, fragment: Fragment): Message;
+/**
+ * @tsplus operator fncts.test.data.Message +
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function prependFragment(fragment: Fragment, self: Message): Message;
+/**
+ * @tsplus operator fncts.test.data.Message +
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function concat_(self: Message, that: Message): Message;
+/**
+ * @tsplus operator fncts.test.data.Message |
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function combine_(self: Message, that: Message): Message;
+/**
+ * @tsplus fluent fncts.test.data.Message drop
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function drop_(self: Message, n: number): Message;
+/**
+ * @tsplus fluent fncts.test.data.Message map
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function map_(self: Message, f: (line: Line) => Line): Message;
+/**
+ * @tsplus fluent fncts.test.data.Message withOffset
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function withOffset(self: Message, offset: number): Message;
+/**
+ * @tsplus fluent fncts.test.data.Message intersperse
+ * @tsplus location "@fncts/test/data/LogLine/Message"
+ */
+export declare function intersperse(self: Message, line: Line): Message;