@fncts/test 0.0.1

package/_src/data/LogLine/Line.ts

@@ -0,0 +1,91 @@
+import { Fragment } from "./Fragment.js";
+import { Message } from "./Message.js";
+
+/**
+ * @tsplus type fncts.test.data.Line
+ * @tsplus companion fncts.test.data.LineOps
+ */
+export class Line {
+  constructor(readonly fragments: Vector<Fragment> = Vector.empty(), readonly offset = 0) {}
+}
+
+/**
+ * @tsplus static fncts.test.data.LineOps empty
+ */
+export const empty = Line();
+
+/**
+ * @tsplus static fncts.test.data.LineOps fromString
+ */
+export function fromString(text: string, offset = 0): Line {
+  return Fragment(text).toLine.withOffset(offset);
+}
+
+/**
+ * @tsplus static fncts.test.data.LineOps __call
+ */
+export function makeLine(fragments: Vector<Fragment> = Vector.empty(), offset = 0): Line {
+  return new Line(fragments, offset);
+}
+
+/**
+ * @tsplus operator fncts.test.data.Line +
+ */
+export function append(self: Line, that: Line): Line {
+  return new Line(self.fragments.concat(that.fragments), self.offset);
+}
+
+/**
+ * @tsplus operator fncts.test.data.Line |
+ */
+export function concat(self: Line, that: Line): Message {
+  return new Message(Vector(self, that));
+}
+
+/**
+ * @tsplus operator fncts.test.data.Line +
+ */
+export function appendTo(message: Message, self: Line): Message {
+  return new Message(message.lines.append(self));
+}
+
+/**
+ * @tsplus operator fncts.test.data.Line +
+ */
+export function prependTo(self: Line, message: Message): Message {
+  return new Message(message.lines.prepend(self));
+}
+
+/**
+ * @tsplus fluent fncts.test.data.Line withOffset
+ */
+export function withOffset(self: Line, shift: number): Line {
+  return new Line(self.fragments, self.offset + shift);
+}
+
+/**
+ * @tsplus getter fncts.test.data.Line toMessage
+ */
+export function toMessage(self: Line): Message {
+  return new Message(Vector(self));
+}
+
+/**
+ * @tsplus getter fncts.test.data.Line optimized
+ */
+export function optimized(self: Line): Line {
+  const newFragments = self.fragments.foldRight(List.empty<Fragment>(), (curr, rest) => {
+    if (rest.isNonEmpty()) {
+      const next = rest.head;
+      const fs   = rest.tail;
+      if (curr.style === next.style) {
+        return Cons(Fragment(curr.text + next.text), fs);
+      } else {
+        return Cons(curr, Cons(next, fs));
+      }
+    } else {
+      return Cons(curr);
+    }
+  });
+  return Line(Vector.from(newFragments), self.offset);
+}

package/_src/data/LogLine/Message.ts

@@ -0,0 +1,94 @@
+import type { Fragment } from "./Fragment.js";
+
+import { Line } from "./Line.js";
+
+/**
+ * @tsplus type fncts.test.data.Message
+ * @tsplus companion fncts.test.data.MessageOps
+ */
+export class Message {
+  constructor(readonly lines: Vector<Line> = Vector.empty()) {}
+}
+
+/**
+ * @tsplus static fncts.test.data.MessageOps empty
+ */
+export const empty: Message = new Message(Vector.empty());
+
+/**
+ * @tsplus static fncts.test.data.MessageOps __call
+ */
+export function makeMessage(lines: Vector<Line> = Vector.empty()): Message {
+  return new Message(lines);
+}
+
+/**
+ * @tsplus operator fncts.test.data.Message +
+ */
+export function appendFragment(self: Message, fragment: Fragment): Message {
+  return self | Message(Vector(Line(Vector(fragment))));
+}
+
+/**
+ * @tsplus operator fncts.test.data.Message +
+ */
+export function prependFragment(fragment: Fragment, self: Message): Message {
+  const lines = self.lines;
+  if (self.lines.isNonEmpty()) {
+    return Message(self.lines.tail.prepend(fragment + self.lines.unsafeHead!));
+  } else {
+    return Message(Vector(fragment.toLine));
+  }
+}
+
+/**
+ * @tsplus operator fncts.test.data.Message +
+ */
+export function concat_(self: Message, that: Message): Message {
+  return Message(self.lines.concat(that.lines));
+}
+
+/**
+ * @tsplus operator fncts.test.data.Message |
+ */
+export function combine_(self: Message, that: Message): Message {
+  const last = self.lines.last;
+  const head = that.lines.head;
+  if (last.isJust() && head.isJust()) {
+    return Message(self.lines.dropLast(1).append(last.value + head.value));
+  } else {
+    return self + that;
+  }
+}
+
+/**
+ * @tsplus fluent fncts.test.data.Message drop
+ */
+export function drop_(self: Message, n: number): Message {
+  return Message(self.lines.drop(n));
+}
+
+/**
+ * @tsplus fluent fncts.test.data.Message map
+ */
+export function map_(self: Message, f: (line: Line) => Line): Message {
+  return Message(self.lines.map(f));
+}
+
+/**
+ * @tsplus fluent fncts.test.data.Message withOffset
+ */
+export function withOffset(self: Message, offset: number): Message {
+  return self.map((line) => line.withOffset(offset));
+}
+
+/**
+ * @tsplus fluent fncts.test.data.Message intersperse
+ */
+export function intersperse(self: Message, line: Line): Message {
+  return new Message(
+    Vector.from(
+      self.lines.foldRight(List.empty<Line>(), (ln, rest) => Cons(ln, rest.isEmpty() ? Nil() : Cons(line, rest))),
+    ),
+  );
+}

package/_src/data/LogLine/Style.ts

@@ -0,0 +1,150 @@
+import type { Fragment } from "./Fragment.js";
+
+export 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
+ */
+export const Primary: Style = {
+  _tag: StyleTag.Primary,
+};
+
+export interface Default {
+  readonly _tag: StyleTag.Default;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Default
+ */
+export const Default: Style = {
+  _tag: StyleTag.Default,
+};
+
+export interface Warning {
+  readonly _tag: StyleTag.Warning;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Warning
+ */
+export const Warning: Style = {
+  _tag: StyleTag.Warning,
+};
+
+export interface Error {
+  readonly _tag: StyleTag.Error;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Error
+ */
+export const Error: Style = {
+  _tag: StyleTag.Error,
+};
+
+export interface Info {
+  readonly _tag: StyleTag.Info;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Info
+ */
+export const Info: Style = {
+  _tag: StyleTag.Info,
+};
+
+export interface Detail {
+  readonly _tag: StyleTag.Detail;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Detail
+ */
+export const Detail: Style = {
+  _tag: StyleTag.Detail,
+};
+
+export interface Dimmed {
+  readonly _tag: StyleTag.Dimmed;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Dimmed
+ */
+export const Dimmed: Style = {
+  _tag: StyleTag.Dimmed,
+};
+
+export interface Bold {
+  readonly _tag: StyleTag.Bold;
+  readonly fr: Fragment;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Bold
+ */
+export function Bold(fr: Fragment): Style {
+  return {
+    _tag: StyleTag.Bold,
+    fr,
+  };
+}
+
+export interface Underlined {
+  readonly _tag: StyleTag.Underlined;
+  readonly fr: Fragment;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Underlined
+ */
+export function Underlined(fr: Fragment): Style {
+  return {
+    _tag: StyleTag.Underlined,
+    fr,
+  };
+}
+
+export interface Ansi {
+  readonly _tag: StyleTag.Ansi;
+  readonly fr: Fragment;
+  readonly ansiColor: string;
+}
+
+/**
+ * @tsplus static fncts.test.data.StyleOps Ansi
+ */
+export function Ansi(fr: Fragment, ansiColor: string): Style {
+  return {
+    _tag: StyleTag.Ansi,
+    fr,
+    ansiColor,
+  };
+}
+
+/**
+ * @tsplus type fncts.test.data.StyleOps
+ */
+export type Style = Primary | Default | Warning | Error | Info | Detail | Dimmed | Bold | Underlined | Ansi;
+
+/**
+ * @tsplus type fncts.test.data.StyleOps
+ */
+export interface StyleOps {}
+
+export const Style: StyleOps = {};

package/_src/data/LogLine/api.ts

@@ -0,0 +1,40 @@
+import { Fragment } from "./Fragment.js";
+import { Style } from "./Style.js";
+
+export function info(s: string): Fragment {
+  return new Fragment(s, Style.Info);
+}
+
+export function error(s: string): Fragment {
+  return new Fragment(s, Style.Error);
+}
+
+export function warn(s: string): Fragment {
+  return new Fragment(s, Style.Warning);
+}
+
+export function primary(s: string): Fragment {
+  return new Fragment(s, Style.Primary);
+}
+
+export function detail(s: string): Fragment {
+  return new Fragment(s, Style.Detail);
+}
+
+export function fr(s: string): Fragment {
+  return new Fragment(s, Style.Default);
+}
+
+export function dim(s: string): Fragment {
+  return new Fragment(s, Style.Dimmed);
+}
+
+export function bold(s: string): Fragment {
+  return fr(s).bold;
+}
+
+export function underlined(s: string): Fragment {
+  return fr(s).underlined;
+}
+
+export const sp = new Fragment(" ");

package/_src/data/LogLine.ts

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

package/_src/data/Render/api.ts

@@ -0,0 +1,18 @@
+import type { RenderParam } from "../RenderParam.js";
+import type { Render } from "./definition.js";
+
+import { RenderFunction, RenderInfix } from "./definition.js";
+
+/**
+ * @tsplus static fncts.test.data.RenderOps fn
+ */
+export function fn(name: string, paramLists: Conc<Conc<RenderParam>>): Render {
+  return new RenderFunction(name, paramLists);
+}
+
+/**
+ * @tsplus static fncts.test.data.RenderOps infix
+ */
+export function infix(left: RenderParam, op: string, right: RenderParam): Render {
+  return new RenderInfix(left, op, right);
+}

package/_src/data/Render/definition.ts

@@ -0,0 +1,36 @@
+import type { RenderParam } from "../RenderParam.js";
+
+export const enum RenderTag {
+  Function = "Function",
+  Infix = "Infix",
+}
+
+export class RenderFunction {
+  readonly _tag = RenderTag.Function;
+  constructor(readonly name: string, readonly paramLists: Conc<Conc<RenderParam>>) {}
+
+  get rendered(): string {
+    return `${this.name}(${this.paramLists.map((ps) => ps.map((p) => p.rendered).join(", ")).join("")})`;
+  }
+}
+
+export class RenderInfix {
+  readonly _tag = RenderTag.Infix;
+  constructor(readonly left: RenderParam, readonly op: string, readonly right: RenderParam) {}
+
+  get rendered(): string {
+    return `(${this.left.rendered} ${this.op} ${this.right.rendered})`;
+  }
+}
+
+/**
+ * @tsplus type fncts.test.data.Render
+ */
+export type Render = RenderFunction | RenderInfix;
+
+/**
+ * @tsplus type fncts.test.data.RenderOps
+ */
+export interface RenderOps {}
+
+export const Render: RenderOps = {};

package/_src/data/Render.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Render/*.ts }
+export * from "./Render/api.js";
+export * from "./Render/definition.js";
+// codegen:end

package/_src/data/RenderParam/api.ts

@@ -0,0 +1,31 @@
+import type { AssertionIO } from "../../control/AssertionIO/definition.js";
+import type { RenderParam } from "./definition.js";
+
+import { show } from "@fncts/base/typeclass/Showable";
+
+import { isAssertionIO } from "../../control/AssertionIO/definition.js";
+import { RenderAssertionIO, RenderParamTag, RenderValue } from "./definition.js";
+
+/**
+ * @tsplus static fncts.test.data.RenderParamOps __call
+ */
+export function param<A>(assertion: AssertionIO<A>): RenderParam;
+export function param<A>(value: A): RenderParam;
+export function param(value: any): RenderParam {
+  if (isAssertionIO(value)) {
+    return new RenderAssertionIO(value);
+  }
+  return new RenderValue(value);
+}
+
+/**
+ * @tsplus getter fncts.test.data.RenderParam rendered
+ */
+export function rendered<A>(self: RenderParam<A>): string {
+  switch (self._tag) {
+    case RenderParamTag.AssertionIO:
+      return self.assertion.rendered;
+    case RenderParamTag.Value:
+      return show(self.value);
+  }
+}

package/_src/data/RenderParam/definition.ts

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

package/_src/data/RenderParam.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./RenderParam/*.ts }
+export * from "./RenderParam/api.js";
+export * from "./RenderParam/definition.js";
+// codegen:end

package/_src/data/Summary.ts

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

package/_src/data/TestAnnotation/api.ts

@@ -0,0 +1,49 @@
+import { TestAnnotation } from "./definition.js";
+
+export const IgnoredTag = Tag<number>();
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Ignored
+ */
+export const Ignored = new TestAnnotation(IgnoredTag, "ignored", 0, (x, y) => x + y);
+
+export const RepeatedTag = Tag<number>();
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Repeated
+ */
+export const Repeated = new TestAnnotation(RepeatedTag, "repeated", 0, (x, y) => x + y);
+
+export const RetriedTag = Tag<number>();
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Retried
+ */
+export const Retried = new TestAnnotation(RetriedTag, "retried", 0, (x, y) => x + y);
+
+export const TaggedTag = Tag<HashSet<string>>();
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Tagged
+ */
+export const Tagged = new TestAnnotation(TaggedTag, "tagged", HashSet.makeDefault(), (x, y) => x.union(y));
+
+export const TimingTag = Tag<number>();
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Timing
+ */
+export const Timing = new TestAnnotation(TimingTag, "timing", 0, (x, y) => x + y);
+
+export const FibersTag = Tag<Either<number, Conc<Ref<HashSet<Fiber.Runtime<any, any>>>>>>();
+/**
+ * @tsplus static fncts.test.TestAnnotationOps Fibers
+ */
+export const Fibers = new TestAnnotation(FibersTag, "fibers", Either.left(0), (left, right) => {
+  return left.isLeft()
+    ? right.isLeft()
+      ? Either.left(left.left + right.left)
+      : right
+    : left.isRight()
+    ? right.isRight()
+      ? Either.right(left.right.concat(right.right))
+      : right
+    : (() => {
+        throw new Error("absurd");
+      })();
+});

package/_src/data/TestAnnotation/definition.ts

@@ -0,0 +1,37 @@
+import { hasTypeId } from "@fncts/base/util/predicates";
+
+export const TestAnnotationTypeId = Symbol.for("fncts.test.TestAnnotation");
+export type TestAnnotationTypeId = typeof TestAnnotationTypeId;
+
+/**
+ * @tsplus type fncts.test.TestAnnotation
+ * @tsplus companion fncts.test.TestAnnotationOps
+ */
+export class TestAnnotation<V> implements Hashable, Equatable {
+  readonly _typeId: TestAnnotationTypeId = TestAnnotationTypeId;
+  readonly _V!: () => V;
+
+  constructor(
+    readonly tag: Tag<V>,
+    readonly identifier: string,
+    readonly initial: V,
+    readonly combine: (v1: V, v2: V) => V,
+  ) {}
+
+  get [Symbol.hash]() {
+    return Hashable.combine(Hashable.string(this.identifier), Hashable.unknown(this.tag));
+  }
+
+  [Symbol.equals](that: unknown) {
+    return (
+      isTestAnnotation(that) &&
+      Equatable.strictEquals(this.tag, that.tag) &&
+      this.identifier === that.identifier &&
+      Equatable.strictEquals(this.initial, that.initial)
+    );
+  }
+}
+
+export function isTestAnnotation(u: unknown): u is TestAnnotation<unknown> {
+  return hasTypeId(u, TestAnnotationTypeId);
+}

package/_src/data/TestAnnotation.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./TestAnnotation/*.ts }
+export * from "./TestAnnotation/api.js";
+export * from "./TestAnnotation/definition.js";
+// codegen:end

package/_src/data/TestAnnotationMap.ts

@@ -0,0 +1,41 @@
+import type { TestAnnotation } from "./TestAnnotation.js";
+
+import { identity } from "@fncts/base/data/function";
+
+export class TestAnnotationMap {
+  constructor(private readonly map: HashMap<TestAnnotation<any>, any>) {}
+
+  combine(that: TestAnnotationMap): TestAnnotationMap {
+    return new TestAnnotationMap(
+      Conc.from(this.map)
+        .concat(Conc.from(that.map))
+        .foldLeft(HashMap.makeDefault(), (acc, [k, v]) =>
+          acc.set(
+            k,
+            acc.get(k).match(
+              () => v,
+              (_) => k.combine(_, v),
+            ),
+          ),
+        ),
+    );
+  }
+
+  get<V>(key: TestAnnotation<V>): V {
+    return this.map.get(key).match(() => key.initial, identity);
+  }
+
+  private overwrite<V>(key: TestAnnotation<V>, value: V): TestAnnotationMap {
+    return new TestAnnotationMap(this.map.set(key, value));
+  }
+
+  private update<V>(key: TestAnnotation<V>, f: (v: V) => V): TestAnnotationMap {
+    return this.overwrite(key, f(this.get(key)));
+  }
+
+  annotate<V>(key: TestAnnotation<V>, value: V): TestAnnotationMap {
+    return this.update(key, (_) => key.combine(_, value));
+  }
+
+  static empty: TestAnnotationMap = new TestAnnotationMap(HashMap.makeDefault());
+}

package/_src/data/TestArgs/definition.ts

@@ -0,0 +1,7 @@
+export class TestArgs {
+  constructor(
+    readonly testSearchTerms: ReadonlyArray<string>,
+    readonly tagSearchTerms: ReadonlyArray<string>,
+    readonly testTaskPolicy: Maybe<string>,
+  ) {}
+}

package/_src/data/TestArgs.ts

@@ -0,0 +1,3 @@
+// codegen:start { preset: barrel, include: ./TestArgs/*.ts }
+export * from "./TestArgs/definition.js";
+// codegen:end