+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| src | +
+
+ |
+ 33.33% | +2/6 | +50% | +1/2 | +50% | +2/4 | +33.33% | +2/6 | +
| src/base | +
+
+ |
+ 100% | +7/7 | +100% | +0/0 | +100% | +3/3 | +100% | +7/7 | +
| src/mixin | +
+
+ |
+ 92.79% | +103/111 | +96.29% | +26/27 | +86.27% | +44/51 | +93.2% | +96/103 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ ++ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 | + + + + + + + + + + + + + + + + +4x + +66x + +66x + +71x + + +66x + + +4x + + | import type { DefaultRegistry, Methods, Registry } from "../registry";
+import type { shim } from "./mixin";
+
+export type Base<T> = T extends { [shim]: { value: infer U } }
+ ? { readonly value: U }
+ : {
+ readonly value: T;
+ };
+
+export type Fluent<
+ T,
+ Reg extends Registry = DefaultRegistry,
+> = Base<T> & Methods<T, Reg>;
+
+export function makeFluent<const Reg extends Registry>(
+ registry: Reg,
+) {
+ const fluent = <const T>(value: T) => {
+ // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+ const f = { value } as never as Fluent<T, Reg>;
+
+ for (const mixin of registry) {
+ // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+ mixin.fn(value, f, fluent as (value: unknown) => never);
+ }
+
+ return f;
+ };
+
+ return fluent;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 | + + + + + + + + + + + + + + + + + + + + + + +5x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import type { Fluent } from ".";
+import { never } from "../internal";
+import type { Registry } from "../registry";
+import type { HKT } from "./hkt";
+
+export interface Props {
+ readonly value: unknown;
+ readonly meta: { registry: Registry };
+}
+
+type MixinHKT = HKT<Props>;
+type MixinFn = (
+ value: unknown,
+ fluent: Record<PropertyKey, unknown>,
+ callback: (value: unknown) => never,
+) => void;
+
+export interface Mixin<T extends MixinHKT = MixinHKT> {
+ hkt: T;
+ fn: MixinFn;
+}
+
+export function Mixin<T extends MixinHKT>(fn: MixinFn): Mixin<T> {
+ return {
+ hkt: never,
+ fn,
+ };
+}
+
+export namespace Mixin {
+ export type HKT = MixinHKT;
+ export type Function = MixinFn;
+}
+
+export declare const shim: unique symbol;
+export interface Shim {
+ input?: unknown;
+ output?: HKT;
+ value?: unknown;
+}
+
+export type Input<P extends Props> = P["value"] extends infer T
+ ? T extends { [shim]: { input: infer I } }
+ ? I
+ : T
+ : never;
+export type Return<T, P extends Props> = Fluent<
+ P["value"] extends { [shim]: { output: infer U extends HKT } }
+ ? HKT.Apply<U, T>
+ : T,
+ P["meta"]["registry"]
+>;
+
+export type Instansiate<
+ M extends Mixin,
+ T,
+ Reg extends Registry,
+> = HKT.Apply<M["hkt"], { value: T; meta: { registry: Reg } }>;
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| internal.ts | +
+
+ |
+ 33.33% | +2/6 | +50% | +1/2 | +50% | +2/4 | +33.33% | +2/6 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 | + + + + + + +4x + + + + + + + + + + + + + + +53x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import type { HKT } from "./base/hkt";
+
+export interface Identity extends HKT {
+ new: (t: HKT.T<this>) => typeof t;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+export const never = undefined as never;
+
+export type Constraint<T, U extends T> = U;
+
+export class AssertionError extends Error {
+ public constructor(msg?: string) {
+ super(msg);
+ this.name = "AssertionError";
+ }
+}
+
+export function assert(
+ condition: unknown,
+ msg?: string,
+): asserts condition {
+ Iif (!Boolean(condition))
+ throw new AssertionError(
+ ["Assertion error", msg]
+ .filter((v) => v !== undefined)
+ .join(": "),
+ );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters, @typescript-eslint/no-unused-vars
+export function assertType<T>(_v: unknown): asserts _v is T {
+ /* empty */
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+type FunctionProto = Function;
+export interface HidePrototype {
+ /** @deprecated */
+ apply: FunctionProto["apply"];
+ /** @deprecated */
+ arguments: FunctionProto["arguments"];
+ /** @deprecated */
+ bind: FunctionProto["bind"];
+ /** @deprecated */
+ call: FunctionProto["call"];
+ /** @deprecated */
+ caller: FunctionProto["caller"];
+ /** @deprecated */
+ length: FunctionProto["length"];
+ /** @deprecated */
+ name: FunctionProto["name"];
+ /** @deprecated */
+ prototype: FunctionProto["prototype"];
+ /** @deprecated */
+ toString: FunctionProto["toString"];
+ /** @deprecated */
+ Symbol: SymbolConstructor;
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +36x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1x +36x + +29x +4x + + +29x +1x +1x + + +29x +1x +1x +1x + + + + +29x +1x + + +29x +1x + +29x +29x + +1x +5x + + + + +29x + + + +1x + +29x +29x + + + + +1x + + + +29x +1x + + +29x + + + + + + +1x +8x + + +29x +29x + +16x + + + + +1x + +8x + + + + +18x + + + + +11x + + +16x + + + + +10x + + + +29x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { makeFluent } from "../base";
+import type { HKT } from "../base/hkt";
+import { Mixin, type Input, type Return } from "../base/mixin";
+import { assert, assertType, type HidePrototype } from "../internal";
+
+type IterArgs<T extends readonly unknown[] = unknown[]> = [
+ element: T[number],
+ idx: number,
+ array: Readonly<T>,
+];
+
+type MaxDepth = 20;
+
+type Unordered<T extends readonly unknown[]> = T extends unknown[]
+ ? T[number][]
+ : readonly T[number][];
+
+type Map<
+ T extends readonly unknown[],
+ U,
+ TOut extends U[] = [],
+> = TOut["length"] extends MaxDepth
+ ? U[]
+ : T extends readonly [infer T, ...infer TRest extends unknown[]]
+ ? Map<TRest, U, [...TOut, U]>
+ : T extends readonly []
+ ? TOut
+ : U[];
+
+type Reverse<
+ T extends readonly unknown[],
+ TOut extends readonly T[number][] = [],
+> = TOut["length"] extends MaxDepth
+ ? T[number][]
+ : T extends readonly [...infer TRest extends unknown[], infer T]
+ ? Reverse<TRest, [...TOut, T]>
+ : T extends readonly []
+ ? TOut
+ : T[number][];
+
+namespace At {
+ export type Dec<N extends number> = [
+ -1,
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9,
+ 10,
+ 11,
+ 12,
+ 13,
+ 14,
+ 15,
+ 16,
+ 17,
+ 18,
+ 19,
+ 20,
+ 21,
+ ][N];
+
+ export type Select<
+ T extends readonly unknown[],
+ Skip extends number,
+ > = Skip extends 0
+ ? T extends readonly [...unknown[], infer T]
+ ? T
+ : undefined
+ : T extends readonly [...infer TRest, unknown]
+ ? Select<TRest, Dec<Skip>>
+ : undefined;
+}
+
+type At<
+ T extends readonly unknown[],
+ K extends keyof T & number,
+> = number extends T["length"]
+ ? T[K] | undefined
+ : `${K}` extends `-${infer N extends number}`
+ ? At.Select<T, At.Dec<N>>
+ : T[K];
+
+type Repeat<
+ T extends readonly unknown[],
+ N extends number,
+ Acc extends null[] = [],
+ TOut extends readonly T[number][] = [],
+> = Acc["length"] extends N
+ ? [...TOut, ...T]
+ : Acc["length"] extends MaxDepth
+ ? T[number][]
+ : Repeat<T, N, [...Acc, null], [...TOut, ...T]>;
+
+namespace Flat {
+ type Inc<
+ N extends number,
+ Acc extends unknown[] = [],
+ > = Acc["length"] extends N
+ ? [...Acc, null]["length"]
+ : Inc<N, [...Acc, null]>;
+
+ export type Leaves<
+ T,
+ Depth extends number = 0,
+ > = Depth extends MaxDepth
+ ? T
+ : T extends readonly unknown[]
+ ? Leaves<T[number], Inc<Depth>>
+ : T;
+
+ export type Rebuild<
+ T extends readonly unknown[],
+ Depth extends number = 0,
+ > = Depth extends MaxDepth
+ ? T
+ : T extends readonly [infer H, ...infer R]
+ ? H extends readonly unknown[]
+ ? [...Rebuild<H, Inc<Depth>>, ...Rebuild<R, Depth>]
+ : [H, ...Rebuild<R, Depth>]
+ : [];
+}
+
+export type Flat<T extends readonly unknown[]> =
+ number extends T["length"] ? Flat.Leaves<T>[] : Flat.Rebuild<T>;
+
+function isArray(v: unknown): v is readonly unknown[] {
+ return typeof v === "object" && globalThis.Array.isArray(v);
+}
+
+export interface Array extends Mixin.HKT {
+ new: (t: HKT.T<this>) => Input<typeof t> extends infer T
+ ? T extends readonly (infer Item)[]
+ ? {
+ /**
+ * Index the array using the specified zero-based index.
+ * Negative indexes start at the end of the array.
+ * @param index Zero-based index
+ * @example
+ * const array = ["first", "middle", "last"] as const;
+ *
+ * const first = $(array).at(0).value;
+ * const middle = $(array).at(1).value;
+ * const last = $(array).at(-1).value;
+ *
+ * expect(first).toBe("first");
+ * expect(middle).toBe("middle");
+ * expect(last).toBe("last");
+ *
+ * const oob = $(array).at(10).value;
+ * expect(oob).toBe(undefined);
+ * @from {@link Array `Array`}
+ */
+ at: <const K extends keyof T & number>(
+ index: K,
+ ) => Return<At<T, K>, typeof t>;
+ /**
+ * Interospect each item of the array using the specified
+ * callback
+ * @param callback Callback taking item, index, and the array for each item.
+ * @example
+ * const array = [4, 5, 6] as const;
+ *
+ * let sum = 0;
+ * const v = $(array).each((n) => { sum += n }).value;
+ *
+ * expect(sum).toBe(15);
+ * expect(v).toMatchObject(array);
+ * @from {@link Array `Array`}
+ */
+ each: (
+ callback: (...args: IterArgs<T>) => void,
+ ) => Return<T, typeof t>;
+ /**
+ * Transform each item of the array using the specified callback
+ * @param callback Transformative callback taking item, index, and array; returns the new item
+ * @example
+ * const chars = ["h", "e", "l", "l", "o"] as const;
+ *
+ * const v = $(chars).map(ch => ch.toUpperCase()).value;
+ * expect(v).toMatchObject(["H", "E", "L", "L", "O"]);
+ * @from {@link Array `Array`}
+ */
+ map: <U>(
+ callback: (...args: IterArgs<T>) => U,
+ ) => Return<Map<T, U>, typeof t>;
+ /**
+ * Extend the array by repeating its current contents n times
+ * @param count The number of repetitions to add
+ * @example
+ * const array = [1, 2];
+ *
+ * const v = $(array).extend(2).value;
+ * expect(v).toMatchObject([1, 2, 1, 2, 1, 2]);
+ * @from {@link Array `Array`}
+ */
+ extend: <const N extends number>(
+ count: N,
+ ) => Return<Repeat<T, N>, typeof t>;
+ /**
+ * Filter the array to contain only items satisfying the
+ * specified callback conditional
+ * @param callback Callback getting item, index, and array for each item and determining if it should be filtered out or not
+ * @example
+ * const dirty = [-2, 4, 1, -5, -6] as const;
+ *
+ * const v = $(dirty).filter(v => v >= 0).value;
+ * expect(v).toMatchObject([4, 1]);
+ * @from {@link Array `Array`}
+ */
+ filter: ((
+ callback: (...args: IterArgs<T>) => boolean,
+ ) => Return<Unordered<T>, typeof t>) & {
+ /**
+ * Filter the array to only contain items which are not
+ * `null` or `undefined`.
+ * @example
+ * const array = new Array(5);
+ *
+ * array[0] = 1;
+ * array[1] = 5;
+ * array[2] = 2;
+ *
+ * const v = $(array).filter.some().value;
+ * expect(v).toMatchObject([1, 5, 2]);
+ * @from {@link Array `Array`}
+ */
+ some: () => Return<
+ T extends unknown[]
+ ? Exclude<
+ T[number],
+ null | undefined
+ >[]
+ : readonly Exclude<
+ T[number],
+ null | undefined
+ >[],
+ typeof t
+ >;
+ } & HidePrototype;
+ reduce: (<U>(
+ initial: U,
+ callback: (
+ value: U,
+ ...args: IterArgs<T>
+ ) => U,
+ ) => Return<U, typeof t>) & {
+ right: <U>(
+ initial: U,
+ callback: (
+ value: U,
+ ...args: IterArgs<T>
+ ) => U,
+ ) => Return<U, typeof t>;
+ } & HidePrototype;
+ length: () => Return<T["length"], typeof t>;
+ sort: ((
+ callback: (
+ a: Item,
+ b: Item,
+ arr: Readonly<T>,
+ ) => number,
+ ) => Return<Unordered<T>, typeof t>) &
+ ([Item] extends [string]
+ ? {
+ alpha: () => Return<
+ Unordered<T>,
+ typeof t
+ >;
+ }
+ : {
+ alpha: (
+ via: (v: Item) => string,
+ ) => Return<
+ Unordered<T>,
+ typeof t
+ >;
+ }) &
+ ([Item] extends [number]
+ ? {
+ ascending: () => Return<
+ Unordered<T>,
+ typeof t
+ >;
+ descending: () => Return<
+ Unordered<T>,
+ typeof t
+ >;
+ }
+ : {
+ ascending: (
+ via: (v: Item) => number,
+ ) => Return<
+ Unordered<T>,
+ typeof t
+ >;
+ descending: (
+ via: (v: Item) => number,
+ ) => Return<
+ Unordered<T>,
+ typeof t
+ >;
+ }) &
+ HidePrototype;
+ reverse: () => Return<Reverse<T>, typeof t>;
+ }
+ : unknown
+ : never;
+}
+export const Array = Mixin<Array>((value, $, fluent) => {
+ if (!isArray(value)) return;
+
+ $.at = (index: number) => {
+ return fluent(value.at(index));
+ };
+
+ $.each = (callback: (...args: IterArgs) => void) => {
+ value.forEach(callback);
+ return fluent(value);
+ };
+
+ $.extend = (count: number) => {
+ assert(count >= 0);
+ Iif (count === 0) return fluent(value);
+ return fluent(
+ value.concat(...new globalThis.Array(count).fill(value)),
+ );
+ };
+
+ $.map = (callback: (...args: IterArgs) => unknown) => {
+ return fluent(value.map(callback));
+ };
+
+ $.filter = (callback: (...args: IterArgs) => boolean) => {
+ return fluent(value.filter(callback));
+ };
+ assertType<object>($.filter);
+ Object.assign($.filter, {
+ some: () => {
+ return fluent(
+ value.filter((v) => v !== null && v !== undefined),
+ );
+ },
+ });
+
+ $.reduce = (
+ initial: unknown,
+ callback: (value: unknown, ...args: IterArgs) => unknown,
+ ) => {
+ return fluent(value.reduce(callback, initial));
+ };
+ assertType<object>($.reduce);
+ Object.assign($.reduce, {
+ right: (
+ initial: unknown,
+ callback: (value: unknown, ...args: IterArgs) => unknown,
+ ) => {
+ return fluent(value.reduceRight(callback, initial));
+ },
+ });
+
+ $.length = () => {
+ return fluent(value.length);
+ };
+
+ $.sort = (
+ callback: (
+ a: unknown,
+ b: unknown,
+ arr: readonly unknown[],
+ ) => number,
+ ) => {
+ return fluent(
+ value.toSorted((a, b) => callback(a, b, value)),
+ );
+ };
+ assertType<object>($.sort);
+ Object.assign($.sort, {
+ alpha: (
+ via: (v: unknown) => string = (v) => (
+ assert(typeof v === "string"),
+ v
+ ),
+ ) => {
+ return fluent(
+ value.toSorted((a, b) =>
+ via(a)! < via(b)! ? -1 : 1,
+ ),
+ );
+ },
+ ascending: (
+ via: (v: unknown) => number = (v) => (
+ assert(typeof v === "number"),
+ v
+ ),
+ ) => {
+ return fluent(value.toSorted((a, b) => via(a) - via(b)));
+ },
+ descending: (
+ via: (v: unknown) => number = (v) => (
+ assert(typeof v === "number"),
+ v
+ ),
+ ) => {
+ return fluent(value.toSorted((a, b) => via(b) - via(a)));
+ },
+ });
+
+ $.reverse = () => {
+ return fluent(value.toReversed());
+ };
+});
+
+if (import.meta.vitest) {
+ const { test, expect, vi } = import.meta.vitest;
+
+ const registry = [Array] as const;
+ const $ = makeFluent(registry);
+
+ test("at()", () => {
+ const arr = [1, 2, 3] as const;
+
+ expect($(arr).at(0).value).toBe(arr[0]);
+ expect($(arr).at(5).value).toBe(undefined);
+
+ expect($(arr).at(-1).value).toBe(arr[arr.length - 1]);
+ expect($(arr).at(-5).value).toBe(undefined);
+ });
+
+ test("each()", () => {
+ const arr = [5, 7, 1] as const;
+ const callback = vi.fn();
+
+ const result = $(arr).each(callback).value;
+
+ expect(result).toMatchObject(arr);
+
+ for (let i = 0; i < arr.length; i++)
+ expect(callback).toHaveBeenNthCalledWith(
+ i + 1,
+ arr[i],
+ i,
+ arr,
+ );
+ });
+
+ test("extend()", () => {
+ const arr = [1, 2] as const;
+
+ const copies = 2;
+ const expected: number[] = new globalThis.Array(copies + 1)
+ .fill(arr)
+ .flat(1);
+
+ expect($(arr).extend(copies).value).toMatchObject(expected);
+ });
+
+ test("map()", () => {
+ const arr = [1, 2, 3, 4, 5] as const;
+ const isEven = vi.fn((v: number) => v % 2 === 0);
+
+ expect($(arr).map(isEven).value).toMatchObject(
+ arr.map(isEven),
+ );
+
+ for (let i = 0; i < arr.length; i++)
+ expect(isEven).toHaveBeenNthCalledWith(
+ i + 1,
+ arr[i],
+ i,
+ arr,
+ );
+ });
+
+ test("filter()", () => {
+ const arr = [5, 4, 3, 2, 1] as const;
+ const isEven = vi.fn((v: number) => v % 2 === 0);
+
+ expect($(arr).filter(isEven).value).toMatchObject(
+ arr.filter(isEven),
+ );
+
+ for (let i = 0; i < arr.length; i++)
+ expect(isEven).toHaveBeenNthCalledWith(
+ i + 1,
+ arr[i],
+ i,
+ arr,
+ );
+
+ const dirty = [1, null, 6, undefined, 2] as const;
+ expect($(dirty).filter.some().value).toMatchObject(
+ dirty.filter((v) => v !== null && v !== undefined),
+ );
+ });
+
+ test("reduce()", () => {
+ const arr = [5, 5, 5, 5, 5] as const;
+
+ const callback = vi.fn((a: number, b: number) => a + b);
+ const expected = arr.reduce(callback, 0);
+
+ callback.mockClear();
+
+ expect($(arr).reduce(0, callback).value).toBe(expected);
+
+ let sum = 0;
+ for (let i = 0; i < arr.length; i++) {
+ expect(callback).toHaveBeenNthCalledWith(
+ i + 1,
+ sum,
+ arr[i],
+ i,
+ arr,
+ );
+ sum += arr[i]!;
+ }
+
+ callback.mockClear();
+
+ expect($(arr).reduce.right(0, callback).value).toBe(expected);
+
+ sum = 0;
+ for (let i = arr.length; i > 0; i--) {
+ expect(callback).toHaveBeenNthCalledWith(
+ arr.length - i + 1,
+ sum,
+ arr[i - 1],
+ i - 1,
+ arr,
+ );
+ sum += arr[i - 1]!;
+ }
+ });
+
+ test("length()", () => {
+ const arr = [3, 3, 3] as const;
+
+ expect($(arr).length().value).toBe(arr.length);
+ });
+
+ test("sort()", () => {
+ const numbers = [1, 5, 3, 4, 2] as const;
+
+ const callback = (a: number) => (a % 2 === 0 ? -1 : 1);
+
+ expect($(numbers).sort(callback).value).toMatchObject(
+ numbers.toSorted(callback),
+ );
+
+ expect($(numbers).sort.ascending().value).toMatchObject(
+ numbers.toSorted((a, b) => a - b),
+ );
+ expect($(numbers).sort.descending().value).toMatchObject(
+ numbers.toSorted((a, b) => b - a),
+ );
+
+ const boxed = [{ v: 3 }, { v: 2 }, { v: 1 }];
+ expect(
+ $(boxed).sort.ascending((v) => v.v).value,
+ ).toMatchObject(boxed.toSorted((a, b) => a.v - b.v));
+ expect(
+ $(boxed).sort.descending((v) => v.v).value,
+ ).toMatchObject(boxed.toSorted((a, b) => b.v - a.v));
+
+ const strings = [
+ "beta",
+ "alpha",
+ "bart",
+ "apple",
+ "charlie",
+ ] as const;
+
+ expect($(strings).sort.alpha().value).toMatchObject(
+ strings.toSorted(),
+ );
+ });
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1x +5x + +3x +1x + + +3x + + +1x +1x + + +1x + +1x + +2x +1x +1x +1x + + +1x +1x +1x +1x + + + + +1x + + + +1x + + +1x +1x + + + + + +1x + +1x + + + +1x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { makeFluent } from "../base";
+import type { HKT } from "../base/hkt";
+import { Mixin, shim, type Input, type Return } from "../base/mixin";
+import { assert, assertType, never } from "../internal";
+import { Base } from "./base";
+
+interface AwaitedIdentitity extends HKT {
+ new: (t: HKT.T<this>) => Awaited<Promise<typeof t>>;
+}
+
+class Awaited<T extends Promise<unknown>> {
+ public value: T;
+ public constructor(value: T) {
+ this.value = value;
+ }
+
+ public get [shim]() {
+ return never as {
+ input: T extends Promise<infer U> ? U : never;
+ output: AwaitedIdentitity;
+ value: T;
+ };
+ }
+}
+
+export interface AsyncMixin extends Mixin.HKT {
+ new: (t: HKT.T<this>) => Input<typeof t> extends infer T
+ ? T extends Promise<unknown>
+ ? {
+ readonly awaited: Return<Awaited<T>, typeof t>;
+ then: <U>(
+ callback: (
+ value: T extends Promise<infer T>
+ ? T
+ : never,
+ ) => U,
+ ) => Return<Promise<U>, typeof t>;
+ }
+ : unknown
+ : never;
+}
+
+interface BaseFluent<T> {
+ value: T;
+ [K: PropertyKey]: unknown;
+}
+
+export const AsyncMixin = Mixin<AsyncMixin>((value, $, fluent) => {
+ if (!(value instanceof Promise)) return;
+
+ $.then = (callback: (value: unknown) => unknown) => {
+ return fluent(value.then(callback));
+ };
+
+ Object.defineProperty($, "awaited", {
+ enumerable: true,
+ get() {
+ let v: Promise<BaseFluent<unknown>> = value.then((v) =>
+ fluent(v),
+ );
+
+ const path: PropertyKey[] = [];
+ // eslint-disable-next-line no-empty-pattern
+ const proxy = new Proxy((...[]: unknown[]) => proxy, {
+ get: (_, key) => {
+ if (key === "value")
+ return v.then((v) => v.value);
+ path.push(key);
+ return proxy;
+ },
+ apply: (target, thisArg, args: unknown[]) => {
+ v = v.then((v) => {
+ let obj: unknown = v;
+ for (const node of path) {
+ assert(
+ typeof obj === "object" &&
+ obj !== null &&
+ node in obj,
+ );
+ assertType<Record<PropertyKey, unknown>>(
+ obj,
+ );
+
+ obj = obj[node];
+ }
+
+ assert(typeof obj === "function");
+ assertType<
+ (
+ ...args: unknown[]
+ ) => BaseFluent<unknown>
+ >(obj);
+
+ return obj(...args);
+ });
+ return target.apply(thisArg, args);
+ },
+ });
+
+ return proxy;
+ },
+ });
+});
+
+if (import.meta.vitest) {
+ const { test, expect } = import.meta.vitest;
+
+ const registry = [Base, AsyncMixin] as const;
+ const $ = makeFluent(registry);
+
+ test(".awaited", async () => {
+ const value = 10;
+ const promise = new Promise<number>((r) => {
+ r(value);
+ });
+
+ const increment = (n: number) => n + 1;
+
+ const result = $(promise).awaited.transform(increment).value;
+
+ expect(await result).toBe(increment(value));
+ });
+
+ test("then()", async () => {
+ const value = 10;
+ const promise = new Promise<number>((r) => {
+ r(value);
+ });
+
+ const increment = (n: number) => n + 1;
+
+ const result = $(promise).then(increment).value;
+
+ expect(await result).toBe(increment(value));
+ });
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2x +12x +1x +1x + + +12x +4x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { makeFluent } from "../base";
+import type { HKT } from "../base/hkt";
+import { Mixin, type Input, type Return } from "../base/mixin";
+
+export interface Base extends Mixin.HKT {
+ new: (t: HKT.T<this>) => Input<typeof t> extends infer T
+ ? {
+ /**
+ * Interospect value using the specified `callback` without
+ * modifying the value.
+ * @param callback The interospective callback
+ * @see `transform` to modify
+ * @example
+ * let x;
+ * const value = $(10).tap(v => { x = ++v }).value;
+ *
+ * expect(x).toBe(11);
+ * expect(value).toBe(10);
+ * @from {@link Base `Base`}
+ */
+ tap(
+ callback: (value: Readonly<T>) => void,
+ ): Return<T, typeof t>;
+ /**
+ * Put value through or pipe value through the specified
+ * `callback` using the outputted return value as a new value.
+ * A.K.A., _transform_ the current value using a callback
+ * @param callback The transformative callback
+ * @example
+ * const value = $("Hello")
+ * .transform(v => v.toUpperCase())
+ * .value;
+ * expect(value).toBe("HELLO");
+ * @from {@link Base `Base`}
+ */
+ transform<U>(
+ callback: (value: T) => U,
+ ): Return<U, typeof t>;
+ }
+ : never;
+}
+
+export const Base = Mixin<Base>((value, $, fluent) => {
+ $.tap = (callback: (value: unknown) => void) => {
+ callback(value);
+ return fluent(value);
+ };
+
+ $.transform = (callback: (value: unknown) => unknown) => {
+ return fluent(callback(value));
+ };
+});
+
+if (import.meta.vitest) {
+ const { test, expect } = import.meta.vitest;
+
+ const registry = [Base] as const;
+ const $ = makeFluent(registry);
+
+ test("tap()", () => {
+ const value = 5;
+ let out = 0;
+
+ const result = $(value).tap((v) => (out = v)).value;
+
+ expect(result).toBe(value);
+ expect(out).toBe(value);
+ });
+
+ test("transform()", () => {
+ const value = 5;
+ const increment = (v: number) => v + 1;
+
+ expect($(value).transform(increment).value).toBe(
+ increment(value),
+ );
+
+ expect(
+ $(value).transform(increment).transform(increment).value,
+ ).toBe(increment(increment(value)));
+ });
+}
+ |
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| array.ts | +
+
+ |
+ 95.55% | +43/45 | +92.3% | +12/13 | +95.83% | +23/24 | +97.56% | +40/41 | +
| awaited.ts | +
+
+ |
+ 93.1% | +27/29 | +100% | +7/7 | +81.81% | +9/11 | +92.3% | +24/26 | +
| base.ts | +
+
+ |
+ 100% | +6/6 | +100% | +0/0 | +100% | +3/3 | +100% | +6/6 | +
| optional.ts | +
+
+ |
+ 87.09% | +27/31 | +100% | +7/7 | +69.23% | +9/13 | +86.66% | +26/30 | +
+ Press n or j to go to the next uncovered block, b, p or k for the previous block. +
+ +| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 | + + + + + + + + + + + + + + +18x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +1x +18x +5x +1x + + +5x +1x + +5x +5x + +1x + + + +5x + + +5x +5x + + + + + +13x +1x + + +13x +1x + + +13x +13x + +1x + + + +13x + + +13x +13x + + + + + + +18x + + + +3x +2x + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | import { makeFluent } from "../base";
+import type { HKT } from "../base/hkt";
+import {
+ Mixin,
+ type Input,
+ type Props,
+ type Return,
+} from "../base/mixin";
+import { assert, assertType, type HidePrototype } from "../internal";
+
+type NoneSentinel = null | undefined;
+type None<T> = Extract<T, NoneSentinel>;
+type Some<T> = Exclude<T, NoneSentinel>;
+
+function isNone<T>(v: T): v is None<T> {
+ return v === null || v === undefined;
+}
+
+interface Where<T, t extends Props> {
+ /**
+ * Set a value to a fallback if it does not conform to some conditional
+ * @param callback Callback returning a boolean, `false` sets the value to the fallback
+ * @param fallback The fallback value, `null` by default
+ * @example
+ * const parse = () => { version: "1.2.4" } as unknown;
+ *
+ * const version = $(parse())
+ * .where(v => typeof v === 'object' &&
+ * v !== null &&
+ * 'version' in v)
+ * .and(v => v.version)
+ * .or("1.0.0")
+ * .value;
+ * expect(version).toBe("1.2.4");
+ * @from {@link Optional `Optional`}
+ */
+ where: <U = null>(
+ callback: (v: T) => boolean,
+ fallback?: U,
+ ) => Return<T | U, t>;
+}
+
+export interface Optional extends Mixin.HKT {
+ new: (t: HKT.T<this>) => Input<typeof t> extends infer T
+ ? None<T> extends never
+ ? Where<T, typeof t>
+ : {
+ /**
+ * Transform a value via callback if it is not `null` or
+ * `undefined`
+ *
+ * If the value is equal to `null` or `undefined`, it
+ * remains unchanged and the callback is not called.
+ * @param callback Function for a non-null value
+ * @example
+ * const none = () => null as number | null;
+ * const some = () => 10 as number | null;
+ *
+ * const callback = (v: number) => v + 5;
+ *
+ * const a = $(none()).and(callback).value;
+ * expect(a).toBe(null)
+ *
+ * const b = $(some()).and(callback).value;
+ * expect(b).toBe(15);
+ * @from {@link Optional `Optional`}
+ */
+ and: <U>(
+ callback: (v: Some<T>) => U,
+ ) => Return<None<T> | U, typeof t>;
+ /**
+ * Set value to a fallback if it is `null` or `undefined`.
+ * @param fallback The fallback value to use. To defer
+ * computing this fallback value, you can use `.or.else()`
+ * @example
+ * const none = () => null as number | null;
+ * const some = () => 10 as number | null;
+ *
+ * const fallback = -1;
+ *
+ * const a = $(none()).or(fallback).value;
+ * expect(a).toBe(fallback);
+ *
+ * const b = $(some()).or(fallback).value;
+ * expect(b).toBe(10);
+ * @from {@link Optional `Optional`}
+ */
+ or: (<U>(
+ fallback: U,
+ ) => Return<Some<T> | U, typeof t>) & {
+ /**
+ * Set value to the result of `callback` if it is `null`
+ * or `undefined`. Unlike the normal `.or()`, this method
+ * only computes the fallback if the value is `null` or
+ * `undefined`
+ * @param callback
+ * @example
+ * const none = () => null as number | null;
+ * const some = () => 8 as number | null;
+ *
+ * const fallback = () => 22; // mocked
+ *
+ * const a = $(none()).or.else(fallback).value;
+ * expect(a).toBe(22);
+ *
+ * const b = $(some()).or.else(fallback).value;
+ * expect(b).toBe(8);
+ *
+ * expect(fallback).toHaveBeenCalledOnce()
+ * @from {@link Optional `Optional`}
+ */
+ else: <U>(
+ callback: (v: None<T>) => U,
+ ) => Return<Some<T> | U, typeof t>;
+ } & HidePrototype;
+ /**
+ * Assert that value is not `null` or `undefined`
+ * @param msg Reasoning to attach to the `AssertionError`
+ * @example
+ * const array = [1, 2, 3];
+ * const element: number | undefined = array[1];
+ *
+ * const v = $(element).assert("index within bounds").value;
+ * expect(v).toBe(2);
+ *
+ * expect(() => {
+ * $(array[6]).assert()
+ * }).toThrow()
+ * @see `.assert.none()` for the inverse assertion
+ * @from {@link Optional `Optional`}
+ */
+ assert: ((
+ msg?: string,
+ ) => Return<Some<T>, typeof t>) & {
+ /**
+ * Assert that the value is either `null` or `undefined`
+ * @param msg Reasoning to attach to the `AssertionError`
+ * @example
+ * const array = [1, 2, 3];
+ * const element: number | undefined = array[5];
+ *
+ * const v = $(element).assert.none("index out of bounds").value;
+ * expect(v).toBe(undefined);
+ *
+ * expect(() => {
+ * $(array[1]).assert.none()
+ * }).toThrow()
+ */
+ none: (
+ msg?: string,
+ ) => Return<None<T>, typeof t>;
+ } & HidePrototype;
+ } & Where<T, typeof t>
+ : never;
+}
+
+export const Optional = Mixin<Optional>((value, $, fluent) => {
+ if (isNone(value)) {
+ $.and = () => {
+ return fluent(value);
+ };
+
+ $.or = (fallback: unknown) => {
+ return fluent(fallback);
+ };
+ assertType<object>($.or);
+ Object.assign($.or, {
+ else: (callback: (v: unknown) => unknown) => {
+ return fluent(callback(value));
+ },
+ });
+
+ $.assert = () => {
+ return fluent(value);
+ };
+ assertType<object>($.assert);
+ Object.assign($.assert, {
+ none: (msg?: string) => {
+ assert(false, msg);
+ },
+ });
+ } else {
+ $.and = (callback: (v: unknown) => unknown) => {
+ return fluent(callback(value));
+ };
+
+ $.or = () => {
+ return fluent(value);
+ };
+
+ assertType<object>($.or);
+ Object.assign($.or, {
+ else: () => {
+ return fluent(value);
+ },
+ });
+
+ $.assert = (msg?: string) => {
+ assert(false, msg);
+ };
+ assertType<object>($.assert);
+ Object.assign($.assert, {
+ none: (msg?: string) => {
+ return fluent(value);
+ },
+ });
+ }
+
+ $.where = (
+ callback: (v: unknown) => boolean,
+ fallback = null,
+ ) => {
+ if (callback(value)) return fluent(value);
+ return fluent(fallback);
+ };
+});
+
+if (import.meta.vitest) {
+ const { test, expect, vi } = import.meta.vitest;
+
+ const registry = [Optional] as const;
+ const $ = makeFluent(registry);
+
+ type Value = number | null;
+
+ test("and()", () => {
+ const value = 10;
+ const some = value as Value;
+ const none = null as Value;
+
+ const callback = (v: number) => v + 5;
+
+ expect($(some).and(callback).value).toBe(callback(value));
+ expect($(none).and(callback).value).toBe(null);
+ });
+
+ test("or()", () => {
+ const some = 10 as Value;
+ const none = null as Value;
+
+ const fallback = 15 as const;
+
+ expect($(some).or(fallback).value).toBe(some);
+ expect($(none).or(fallback).value).toBe(fallback);
+
+ const callback = vi.fn(() => fallback);
+
+ expect($(some).or.else(callback).value).toBe(some);
+ expect($(none).or.else(callback).value).toBe(fallback);
+
+ expect(callback).toHaveBeenCalledOnce();
+ });
+
+ test("where()", () => {
+ const even = 4;
+ const odd = 7;
+
+ const isEven = (v: number) => v % 2 === 0;
+
+ expect($(even).where(isEven).value).toBe(even);
+ expect($(odd).where(isEven).value).toBe(null);
+
+ expect($(odd).where(isEven, -1).value).toBe(-1);
+ });
+}
+ |