refactor dynamic.ts, remove ScanAction casts

Author: cscheid

src/command/check/check.ts

@@ -47,7 +47,7 @@ import { notebookContext } from "../../render/notebook/notebook-context.ts";
 import { typstBinaryPath } from "../../core/typst.ts";
 import { quartoCacheDir } from "../../core/appdirs.ts";
 import { isWindows } from "../../deno_ral/platform.ts";
-import { checkStringEnum } from "../../typing/dynamic.ts";
+import { makeStringEnumTypeEnforcer } from "../../typing/dynamic.ts";
 
 export const kTargets = [
   "install",
@@ -58,7 +58,7 @@ export const kTargets = [
   "all",
 ] as const;
 export type Target = typeof kTargets[number];
-export const checkTargetType = checkStringEnum(...kTargets);
+export const enforceTargetType = makeStringEnumTypeEnforcer(...kTargets);
 
 const kIndent = "      ";
 

src/command/check/cmd.ts

@@ -5,7 +5,7 @@
  */
 
 import { Command } from "cliffy/command/mod.ts";
-import { check, checkTargetType } from "./check.ts";
+import { check, enforceTargetType } from "./check.ts";
 
 export const checkCommand = new Command()
   .name("check")
@@ -20,5 +20,5 @@ export const checkCommand = new Command()
   .example("Check installation and all engines", "quarto check all")
   .action(async (_options: unknown, targetStr?: string) => {
     targetStr = targetStr || "all";
-    await check(checkTargetType(targetStr));
+    await check(enforceTargetType(targetStr));
   });

src/command/create/editor.ts

@@ -16,6 +16,12 @@ import {
 import { basename, dirname, join } from "../../deno_ral/path.ts";
 import { existsSync } from "../../deno_ral/fs.ts";
 import { isMac, isWindows } from "../../deno_ral/platform.ts";
+import {
+  enforcer,
+  makeStringEnumTypeFunctions,
+  objectPredicate,
+  stringTypePredicate,
+} from "../../typing/dynamic.ts";
 
 export interface Editor {
   // A short, command line friendly id
@@ -77,11 +83,14 @@ interface EditorInfo {
   open: (path: string, createResult: CreateResult) => () => Promise<void>;
 }
 
-interface ScanAction {
-  action: "path" | "which" | "env";
+const scanActionActions = ["path", "which", "env"] as const;
+type ScanActionAction = typeof scanActionActions[number];
+
+type ScanAction = {
+  action: ScanActionAction;
   arg: string;
   filter?: (path: string) => string;
-}
+};
 
 function vscodeEditorInfo(): EditorInfo {
   const editorInfo: EditorInfo = {
@@ -110,29 +119,26 @@ function vscodeEditorInfo(): EditorInfo {
       action: "which",
       arg: "code.exe",
     });
-    const pathActions = windowsAppPaths("Microsoft VS Code", "code.exe").map(
-      (path) => {
-        return {
-          action: "path",
-          arg: path,
-        } as ScanAction;
-      },
-    );
+    const pathActions: ScanAction[] = windowsAppPaths(
+      "Microsoft VS Code",
+      "code.exe",
+    ).map((path) => ({
+      action: "path",
+      arg: path,
+    }));
     editorInfo.actions.push(...pathActions);
   } else if (isMac) {
     editorInfo.actions.push({
       action: "which",
       arg: "code",
     });
 
-    const pathActions = macosAppPaths(
+    const pathActions: ScanAction[] = macosAppPaths(
       "Visual Studio Code.app/Contents/Resources/app/bin/code",
-    ).map((path) => {
-      return {
-        action: "path",
-        arg: path,
-      } as ScanAction;
-    });
+    ).map((path) => ({
+      action: "path",
+      arg: path,
+    }));
     editorInfo.actions.push(...pathActions);
   } else {
     editorInfo.actions.push({
@@ -174,13 +180,14 @@ function positronEditorInfo(): EditorInfo {
       action: "which",
       arg: "Positron.exe",
     });
-    const pathActions = windowsAppPaths("Positron", "Positron.exe").map(
-      (path) => {
-        return {
-          action: "path",
-          arg: path,
-        } as ScanAction;
-      },
+    const pathActions: ScanAction[] = windowsAppPaths(
+      "Positron",
+      "Positron.exe",
+    ).map(
+      (path) => ({
+        action: "path",
+        arg: path,
+      }),
     );
     editorInfo.actions.push(...pathActions);
   } else if (isMac) {
@@ -189,13 +196,13 @@ function positronEditorInfo(): EditorInfo {
       arg: "positron",
     });
 
-    const pathActions = macosAppPaths(
+    const pathActions: ScanAction[] = macosAppPaths(
       "Positron.app/Contents/Resources/app/bin/code",
     ).map((path) => {
       return {
         action: "path",
         arg: path,
-      } as ScanAction;
+      };
     });
     editorInfo.actions.push(...pathActions);
   } else {
@@ -249,22 +256,19 @@ function rstudioEditorInfo(): EditorInfo {
       },
     });
 
-    const paths = windowsAppPaths(join("RStudio", "bin"), rstudioExe).map(
-      (path) => {
-        return {
-          action: "path",
-          arg: path,
-        } as ScanAction;
-      },
-    );
+    const paths: ScanAction[] = windowsAppPaths(
+      join("RStudio", "bin"),
+      rstudioExe,
+    ).map((path) => ({
+      action: "path",
+      arg: path,
+    }));
     editorInfo.actions.push(...paths);
   } else if (isMac) {
-    const paths = macosAppPaths("RStudio.app").map((path) => {
-      return {
-        action: "path",
-        arg: path,
-      } as ScanAction;
-    });
+    const paths: ScanAction[] = macosAppPaths("RStudio.app").map((path) => ({
+      action: "path",
+      arg: path,
+    }));
     editorInfo.actions.push(...paths);
   } else {
     editorInfo.actions.push({

src/typing/dynamic.ts

@@ -11,17 +11,62 @@
 
 import { DynamicTypeCheckError } from "../core/lib/error.ts";
 
-export const checkStringEnum = <T extends string>(
+export const makeStringEnumTypeFunctions = <T extends string>(
   ...values: T[]
-): (value: string) => T => {
+): {
+  predicate: (value: unknown) => value is T;
+  enforce: (value: unknown) => T;
+} => {
   const valueSet: Set<string> = new Set(values);
-  return (value: string): T => {
-    if (!valueSet.has(value)) {
-      throw new DynamicTypeCheckError(
-        "Invalid value '" + value + "' (valid values are " +
-          values.join(", ") + ").",
-      );
+  const predicate = (value: unknown): value is T => {
+    return typeof value === "string" && valueSet.has(value);
+  };
+  const enforce = (value: unknown): T => {
+    if (predicate(value)) {
+      return value;
+    }
+    throw new DynamicTypeCheckError(
+      "Invalid value '" + value + "' (valid values are " +
+        values.join(", ") + ").",
+    );
+  };
+  return { predicate, enforce };
+};
+
+export const makeStringEnumTypeEnforcer = <T extends string>(
+  ...values: T[]
+): (value: unknown) => T => {
+  return makeStringEnumTypeFunctions(...values).enforce;
+};
+
+export const enforcer = <T>(
+  predicate: (value: unknown) => value is T,
+  msg?: (value: unknown) => string,
+) => {
+  if (!msg) {
+    msg = (_value: unknown) => "Invalid value.";
+  }
+  return (value: unknown): T => {
+    if (predicate(value)) {
+      return value;
     }
-    return value as unknown as T;
+    throw new DynamicTypeCheckError(msg(value));
   };
 };
+
+export const enforceStringType = (value: unknown): string => {
+  if (stringTypePredicate(value)) {
+    return value;
+  }
+  throw new DynamicTypeCheckError("Expected a string.");
+};
+
+export const stringTypePredicate = (value: unknown): value is string => {
+  return typeof value === "string";
+};
+
+export const objectPredicate = (
+  value: unknown,
+): value is Record<string, unknown> => {
+  return typeof value === "object" && value !== null;
+};

tests/unit/typing/dynamic.test.ts

@@ -5,13 +5,13 @@
 *
 */
 
-import { checkStringEnum } from "../../../src/typing/dynamic.ts";
+import { makeStringEnumTypeEnforcer } from "../../../src/typing/dynamic.ts";
 import { unitTest } from "../../test.ts";
 import { assert, assertThrows } from "testing/asserts";
 
 // deno-lint-ignore require-await
-unitTest("checkStringEnum", async () => {
-  const check = checkStringEnum("a", "b", "c");
+unitTest("makeStringEnumTypeEnforcer", async () => {
+  const check = makeStringEnumTypeEnforcer("a", "b", "c");
   assert(check("a") === "a");
   assert(check("b") === "b");
   assert(check("c") === "c");