Allow mixing .is() with .true()

jest.config.js

@@ -4,6 +4,6 @@ module.exports = {
   transform: { "\\.ts$": "ts-jest" },
   moduleFileExtensions: ["ts", "js"],
   globals: {
-    "ts-jest": { enableTsDiagnostics: true }
+    "ts-jest": { diagnostics: true }
   }
 };

src/__tests__/true.spec.ts

@@ -65,3 +65,38 @@ describe("'when.true' syntax with assertion wrapped in thunk", () => {
     expect(isBuffer({ isBuffer: () => false })).toBe(2);
   });
 });
+
+describe("'when.true' mixed with when(subject) syntax", () => {
+
+  it("should allow to call method is() after method true()", () => {
+    const whenTrue = (subject: any, bool: boolean) =>
+      when(subject)
+        .true(bool, true);
+
+    expect(whenTrue({}, true)).toHaveProperty("is");
+  });
+
+  it("should allow to call method true() after method true()", () => {
+    const whenTrue = (subject: any, bool: boolean) =>
+      when(subject)
+        .true(bool, true);
+
+    expect(whenTrue({}, true)).toHaveProperty("true");
+  });
+
+  it("should allow to call method true() after method is()", () => {
+    const whenIs = (subject: string) =>
+      when(subject)
+        .is("funny", 420);
+
+    expect(whenIs("whatever")).toHaveProperty("true");
+  });
+
+  it("should allow to call method is() after method is()", () => {
+    const whenIs = (subject: string) =>
+      when(subject)
+        .is("funny", 420);
+
+    expect(whenIs("whatever")).toHaveProperty("is");
+  });
+});

src/when.ts

@@ -6,15 +6,22 @@ export interface Matcher<T, R extends T> {
 export interface When<T, V> {
   is: <U extends T, W>(
     matcher: U,
-    returnValue: ((inputValue: U) => W) | W,
+    value: ((inputValue: U) => W) | W,
   ) => When<T, V | W>;
 
   match: <U extends T, W>(
     matcher: Matcher<T, U>,
-    returnValue: ((inputValue: U) => W) | W,
+    value: ((inputValue: U) => W) | W,
   ) => When<T, V | W>;
 
-  else: <W>(returnValue: ((inputValue: T) => W) | W) => V | W;
+  true: <W>(
+    assertion: (() => boolean) | boolean,
+    value: (() => W) | W,
+  ) => When<T, V | W>;
+
+  else: <W>(
+    returnValue: ((inputValue: T) => W) | W,
+  ) => V | W;
 }
 
 export interface WhenSwitch {
@@ -36,6 +43,7 @@ export interface True<T> {
 const resolve = (resolvedValue: any): When<any, any> => ({
   is: () => resolve(resolvedValue),
   match: () => resolve(resolvedValue),
+  true: () => resolve(resolvedValue),
   else: () => resolvedValue,
 });
 
@@ -53,6 +61,11 @@ export const when = (<T>(expr: T): When<T, never> => ({
       ? resolve(typeof value === "function" ? (value as (x: any) => any)(expr) : value)
       : when(expr),
 
+  true: (assertion, value) =>
+    (typeof assertion === "function" ? assertion() : assertion)
+      ? resolve(typeof value === "function" ? (value as (() => any))() : value)
+      : when(expr),
+
   else: (defaultValue) =>
     typeof defaultValue === "function" ? (defaultValue as (x: any) => any)(expr) : defaultValue,
 })) as WhenSwitch;

tslint.json

@@ -7,7 +7,12 @@
     "rules": {
         "interface-name": false,
         "object-literal-sort-keys": false,
-        "ordered-imports": false
+        "ordered-imports": false,
+        "indent": [
+            true,
+            "spaces",
+            2
+        ]
     },
     "rulesDirectory": []
 }