@caleuche/cli 0.2.4 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @caleuche/cli
 
+## 0.3.0
+
+### Minor Changes
+
+- ff834ac: Changing batch file schema.
+
 ## 0.2.4
 
 ### Patch Changes

package/dist/batch.js

@@ -4,54 +4,67 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.batchCompile = batchCompile;
-const fs_1 = __importDefault(require("fs"));
 const utils_1 = require("./utils");
 const common_1 = require("./common");
 const path_1 = __importDefault(require("path"));
-function loadVariantDefinition(variant, workingDirectory) {
-    if ((0, utils_1.isVariantDefinition)(variant)) {
-        return variant;
+function loadVariantInputDefinition(variantInput, workingDirectory) {
+    if ((0, utils_1.isVariantInputDefinition)(variantInput)) {
+        return variantInput;
     }
-    else if (fs_1.default.existsSync(path_1.default.join(workingDirectory, variant))) {
-        const v = (0, utils_1.parse)(path_1.default.join(workingDirectory, variant));
-        if (!v) {
-            console.error(`Failed to parse variant at path: ${variant}`);
+    else {
+        const absolutePath = path_1.default.join(workingDirectory, variantInput.value);
+        if ((0, utils_1.isFile)(absolutePath)) {
+            const v = (0, utils_1.parse)(absolutePath);
+            if (!v) {
+                console.error(`Failed to parse variant at path: ${absolutePath}`);
+                return null;
+            }
+            return v;
+        }
+        else {
+            console.error(`Variant input path "${variantInput.value}" does not exist or is not a file.`);
             return null;
         }
-        return v;
     }
-    return null;
 }
 function loadVariantDefinitions(variants, workingDirectory) {
     if (!variants)
         return {};
     const definitions = {};
-    for (const [key, variant] of Object.entries(variants)) {
-        const v = loadVariantDefinition(variant, workingDirectory);
+    for (const { name, input } of variants) {
+        const v = loadVariantInputDefinition(input, workingDirectory);
         if (!v) {
-            console.error(`Failed to load variant definition for key "${key}": ${variant}`);
+            console.error(`Failed to load variant definition for key "${name}": ${input}`);
             return null;
         }
-        definitions[key] = v;
+        definitions[name] = v;
     }
     return definitions;
 }
 function resolveVariantDefinition(variant, variantRegistry, workingDirectory) {
-    if ((0, utils_1.isVariantDefinition)(variant.data)) {
-        return variant.data;
-    }
-    if ((0, utils_1.isFile)(path_1.default.join(workingDirectory, variant.data))) {
-        const v = (0, utils_1.parse)(path_1.default.join(workingDirectory, variant.data));
+    if ((0, utils_1.isVariantInputReference)(variant.input)) {
+        const ref = (0, utils_1.getVariantInputReferenceValue)(variant.input);
+        const v = variantRegistry[ref];
         if (v) {
             return v;
         }
+        console.error(`Variant "${ref}" could not be resolved.`);
+        return null;
+    }
+    else if ((0, utils_1.isVariantInputDefinition)(variant.input)) {
+        return variant.input;
     }
-    const v = variantRegistry[variant.data];
-    if (v) {
-        return v;
+    else {
+        const absolutePath = path_1.default.join(workingDirectory, variant.input.value);
+        if ((0, utils_1.isFile)(absolutePath)) {
+            const v = (0, utils_1.parse)(absolutePath);
+            if (v) {
+                return v;
+            }
+        }
+        console.error(`Variant input path "${variant.input.value}" does not exist or is not a file.`);
+        return null;
     }
-    console.error(`Variant "${variant.data}" could not be resolved.`);
-    return null;
 }
 function batchCompile(batchFile) {
     if (!(0, utils_1.isFile)(batchFile)) {
@@ -60,17 +73,17 @@ function batchCompile(batchFile) {
     }
     const workingDirectory = (0, utils_1.getAbsoluteDirectoryPath)(batchFile);
     console.log(`Working directory: ${workingDirectory}`);
-    const bachDefinition = (0, utils_1.parse)(batchFile);
-    if (!bachDefinition) {
+    const batchDefinition = (0, utils_1.parse)(batchFile);
+    if (!batchDefinition) {
         console.error(`Failed to parse batch file: ${batchFile}`);
         process.exit(1);
     }
-    const variants = loadVariantDefinitions(bachDefinition.variants, workingDirectory);
+    const variants = loadVariantDefinitions(batchDefinition.variants, workingDirectory);
     console.log(`Loaded ${Object.keys(variants || {}).length} variant definitions from batch file.`);
     if (!variants) {
         process.exit(1);
     }
-    const samples = bachDefinition.samples;
+    const samples = batchDefinition.samples;
     for (const sampleDefinition of samples) {
         console.log(`Processing sample: ${sampleDefinition.templatePath}`);
         const templatePath = path_1.default.join(workingDirectory, sampleDefinition.templatePath);

package/dist/utils.js

@@ -9,7 +9,10 @@ exports.isDirectory = isDirectory;
 exports.createOutputDirectory = createOutputDirectory;
 exports.resolveTemplate = resolveTemplate;
 exports.isObject = isObject;
-exports.isVariantDefinition = isVariantDefinition;
+exports.isVariantInputDefinition = isVariantInputDefinition;
+exports.isVariantInputPath = isVariantInputPath;
+exports.isVariantInputReference = isVariantInputReference;
+exports.getVariantInputReferenceValue = getVariantInputReferenceValue;
 exports.getAbsoluteDirectoryPath = getAbsoluteDirectoryPath;
 exports.isFile = isFile;
 const yaml_1 = require("yaml");
@@ -57,8 +60,21 @@ function resolveTemplate(samplePath, sample) {
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isVariantDefinition(variant) {
-    return isObject(variant) && !Array.isArray(variant);
+function isVariantInputDefinition(variant) {
+    return isObject(variant) && variant.type === "object";
+}
+function isVariantInputPath(variant) {
+    return isObject(variant) && variant.type === "path";
+}
+function isVariantInputReference(variant) {
+    return ((isObject(variant) && variant.type === "reference") ||
+        typeof variant === "string");
+}
+function getVariantInputReferenceValue(variant) {
+    if (typeof variant === "string") {
+        return variant;
+    }
+    return variant.value;
 }
 function getAbsoluteDirectoryPath(filePath) {
     return path_1.default.dirname(path_1.default.resolve(filePath));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caleuche/cli",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"

package/src/batch.ts

@@ -1,72 +1,85 @@
-import fs from "fs";
 import {
   getAbsoluteDirectoryPath,
+  getVariantInputReferenceValue,
   isFile,
-  isVariantDefinition,
+  isVariantInputDefinition,
+  isVariantInputReference,
   parse,
 } from "./utils";
 import { compileAndWriteOutput, resolveAndParseSample } from "./common";
 import path from "path";
 
-function loadVariantDefinition(
-  variant: SampleVariantDefinition | SampleVariantPath,
-  workingDirectory: string
-): SampleVariantDefinition | null {
-  if (isVariantDefinition(variant)) {
-    return variant;
-  } else if (fs.existsSync(path.join(workingDirectory, variant))) {
-    const v = parse<SampleVariantDefinition>(path.join(workingDirectory, variant));
-    if (!v) {
-      console.error(`Failed to parse variant at path: ${variant}`);
+function loadVariantInputDefinition(
+  variantInput: SampleVariantInputDefinition | SampleVariantInputPath,
+  workingDirectory: string,
+): SampleVariantInputDefinition | null {
+  if (isVariantInputDefinition(variantInput)) {
+    return variantInput;
+  } else {
+    const absolutePath = path.join(workingDirectory, variantInput.value);
+    if (isFile(absolutePath)) {
+      const v = parse<SampleVariantInputDefinition>(absolutePath);
+      if (!v) {
+        console.error(`Failed to parse variant at path: ${absolutePath}`);
+        return null;
+      }
+      return v;
+    } else {
+      console.error(
+        `Variant input path "${variantInput.value}" does not exist or is not a file.`,
+      );
       return null;
     }
-    return v;
   }
-  return null;
 }
 
 function loadVariantDefinitions(
-  variants: Record<string, SampleVariantDefinition | SampleVariantPath> | undefined,
-  workingDirectory: string
-): Record<string, SampleVariantDefinition> | null {
+  variants: SampleVariantInputEntry[] | undefined,
+  workingDirectory: string,
+): Record<string, SampleVariantInputDefinition> | null {
   if (!variants) return {};
-  const definitions: Record<string, SampleVariantDefinition> = {};
-  for (const [key, variant] of Object.entries(variants)) {
-    const v = loadVariantDefinition(variant, workingDirectory);
+  const definitions: Record<string, SampleVariantInputDefinition> = {};
+  for (const { name, input } of variants) {
+    const v = loadVariantInputDefinition(input, workingDirectory);
     if (!v) {
       console.error(
-        `Failed to load variant definition for key "${key}": ${variant}`,
+        `Failed to load variant definition for key "${name}": ${input}`,
       );
       return null;
     }
-    definitions[key] = v;
+    definitions[name] = v;
   }
   return definitions;
 }
 
 function resolveVariantDefinition(
   variant: SampleVariantConfig,
-  variantRegistry: Record<string, SampleVariantDefinition>,
-  workingDirectory: string
-): SampleVariantDefinition | null {
-  if (isVariantDefinition(variant.data)) {
-    return variant.data;
-  }
-
-  if (isFile(path.join(workingDirectory, variant.data))) {
-    const v = parse<SampleVariantDefinition>(path.join(workingDirectory, variant.data));
+  variantRegistry: Record<string, SampleVariantInputDefinition>,
+  workingDirectory: string,
+): SampleVariantInputDefinition | null {
+  if (isVariantInputReference(variant.input)) {
+    const ref = getVariantInputReferenceValue(variant.input);
+    const v = variantRegistry[ref];
     if (v) {
       return v;
     }
-  }
-
-
-    const v = variantRegistry[variant.data];
-    if (v) {
-      return v;
+    console.error(`Variant "${ref}" could not be resolved.`);
+    return null;
+  } else if (isVariantInputDefinition(variant.input)) {
+    return variant.input;
+  } else {
+    const absolutePath = path.join(workingDirectory, variant.input.value);
+    if (isFile(absolutePath)) {
+      const v = parse<SampleVariantInputDefinition>(absolutePath);
+      if (v) {
+        return v;
+      }
     }
-    console.error(`Variant "${variant.data}" could not be resolved.`);
-    return null
+    console.error(
+      `Variant input path "${variant.input.value}" does not exist or is not a file.`,
+    );
+    return null;
+  }
 }
 
 export function batchCompile(batchFile: string) {
@@ -76,19 +89,22 @@ export function batchCompile(batchFile: string) {
   }
   const workingDirectory = getAbsoluteDirectoryPath(batchFile);
   console.log(`Working directory: ${workingDirectory}`);
-  const bachDefinition = parse<BatchCompileOptions>(batchFile);
-  if (!bachDefinition) {
+  const batchDefinition = parse<BatchCompileDescription>(batchFile);
+  if (!batchDefinition) {
     console.error(`Failed to parse batch file: ${batchFile}`);
     process.exit(1);
   }
-  const variants = loadVariantDefinitions(bachDefinition.variants, workingDirectory);
+  const variants = loadVariantDefinitions(
+    batchDefinition.variants,
+    workingDirectory,
+  );
   console.log(
     `Loaded ${Object.keys(variants || {}).length} variant definitions from batch file.`,
   );
   if (!variants) {
     process.exit(1);
   }
-  const samples = bachDefinition.samples;
+  const samples = batchDefinition.samples;
   for (const sampleDefinition of samples) {
     console.log(`Processing sample: ${sampleDefinition.templatePath}`);
     const templatePath = path.join(
@@ -102,15 +118,16 @@ export function batchCompile(batchFile: string) {
 
     for (const variant of sampleDefinition.variants) {
       console.log("Processing variant...");
-      const resolvedVariant = resolveVariantDefinition(variant, variants, workingDirectory);
+      const resolvedVariant = resolveVariantDefinition(
+        variant,
+        variants,
+        workingDirectory,
+      );
       if (!resolvedVariant) {
         process.exit(1);
       }
 
-      const effectiveOutputPath = path.join(
-        workingDirectory,
-        variant.output,
-      );
+      const effectiveOutputPath = path.join(workingDirectory, variant.output);
 
       if (
         !compileAndWriteOutput(sample, resolvedVariant, effectiveOutputPath, {

package/src/interfaces.ts

@@ -1,14 +1,26 @@
-type SampleVariantDefinition = Record<string, any>;
-type SampleVariantReference = string;
-type SampleVariantPath = string;
-type SampleVariant =
-  | SampleVariantDefinition
-  | SampleVariantReference
-  | SampleVariantPath;
+interface SampleVariantInputDefinition {
+  type: "object";
+  properties: Record<string, any>;
+}
+
+interface SampleVariantInputReference {
+  type: "reference";
+  value: string;
+}
+
+interface SampleVariantInputPath {
+  type: "path";
+  value: string;
+}
+
+type SampleVariantInput =
+  | SampleVariantInputDefinition
+  | SampleVariantInputReference
+  | SampleVariantInputPath;
 
 interface SampleVariantConfig {
   output: string;
-  data: SampleVariant;
+  input: SampleVariantInput | string;
 }
 
 interface SampleDefinition {
@@ -16,7 +28,12 @@ interface SampleDefinition {
   variants: SampleVariantConfig[];
 }
 
-interface BatchCompileOptions {
-  variants?: Record<string, SampleVariantDefinition | SampleVariantPath>;
+interface SampleVariantInputEntry {
+  name: string;
+  input: SampleVariantInputDefinition | SampleVariantInputPath;
+}
+
+interface BatchCompileDescription {
+  variants?: SampleVariantInputEntry[];
   samples: SampleDefinition[];
 }

package/src/utils.ts

@@ -52,15 +52,37 @@ export function isObject(value: any): value is Record<string, any> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 
-export function isVariantDefinition(
-  variant: SampleVariant,
-): variant is SampleVariantDefinition {
-  return isObject(variant) && !Array.isArray(variant);
+export function isVariantInputDefinition(
+  variant: SampleVariantInput,
+): variant is SampleVariantInputDefinition {
+  return isObject(variant) && variant.type === "object";
 }
 
-export function getAbsoluteDirectoryPath(
-  filePath: string,
+export function isVariantInputPath(
+  variant: SampleVariantInput,
+): variant is SampleVariantInputPath {
+  return isObject(variant) && variant.type === "path";
+}
+
+export function isVariantInputReference(
+  variant: SampleVariantInput | string,
+): variant is SampleVariantInputReference | string {
+  return (
+    (isObject(variant) && variant.type === "reference") ||
+    typeof variant === "string"
+  );
+}
+
+export function getVariantInputReferenceValue(
+  variant: SampleVariantInputReference | string,
 ): string {
+  if (typeof variant === "string") {
+    return variant;
+  }
+  return variant.value;
+}
+
+export function getAbsoluteDirectoryPath(filePath: string): string {
   return path.dirname(path.resolve(filePath));
 }
 

package/test/bach.test.ts

@@ -15,15 +15,21 @@ import {
   resolveSampleFile,
   createOutputDirectory,
   resolveTemplate,
-  isVariantDefinition,
+  isVariantInputDefinition,
   getAbsoluteDirectoryPath,
   isFile,
+  isVariantInputReference,
+  getVariantInputReferenceValue,
 } from "../src/utils";
 const mockParse = vi.mocked(parse);
 const mockResolveSampleFile = vi.mocked(resolveSampleFile);
 const mockCreateOutputDirectory = vi.mocked(createOutputDirectory);
 const mockResolveTemplate = vi.mocked(resolveTemplate);
-const mockIsVariantDefinition = vi.mocked(isVariantDefinition);
+const mockIsVariantInputReference = vi.mocked(isVariantInputReference);
+const mockGetVariantInputReferenceValue = vi.mocked(
+  getVariantInputReferenceValue,
+);
+const mockIsVariantInputDefinition = vi.mocked(isVariantInputDefinition);
 const mockGetAbsoluteDirectoryPath = vi.mocked(getAbsoluteDirectoryPath);
 const mockIsFile = vi.mocked(isFile);
 
@@ -51,7 +57,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -63,7 +69,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -76,7 +82,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -86,7 +92,9 @@ describe("batchCompile", () => {
     mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
     mockParse
       .mockImplementationOnce(() => ({
-        variants: { foo: "badvariant.yaml" },
+        variants: [
+          { name: "foo", input: { type: "path", value: "badvariant.yaml" } },
+        ],
         samples: [],
       }))
       .mockImplementationOnce(() => null);
@@ -103,7 +111,7 @@ describe("batchCompile", () => {
     mockIsFile.mockReturnValue(true);
     mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [{ templatePath: "sample.yaml", variants: [], output: "out" }],
     });
     mockResolveSampleFile.mockReturnValue("sample.yaml");
@@ -121,10 +129,10 @@ describe("batchCompile", () => {
     mockFs.existsSync.mockReturnValue(true);
     mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
         { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
-      ]
+      ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
     mockParse.mockReturnValueOnce(null);
@@ -132,7 +140,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -141,9 +149,12 @@ describe("batchCompile", () => {
     mockIsFile.mockReturnValue(true);
     mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
-        { templatePath: "sample.yaml", variants: [{ output: "out", data: "v1" }] },
+        {
+          templatePath: "sample.yaml",
+          variants: [{ output: "out", input: "v1" }],
+        },
       ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
@@ -154,7 +165,9 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(false);
+    mockIsVariantInputReference.mockReturnValue(true);
+    mockGetVariantInputReferenceValue.mockReturnValue("v1");
+    mockIsVariantInputDefinition.mockReturnValue(false);
     expect(() => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
@@ -168,11 +181,11 @@ describe("batchCompile", () => {
     mockIsFile.mockReturnValue(true);
     mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
         {
           templatePath: "sample.yaml",
-          variants: [{ output: "out", data: "v1" }],
+          variants: [{ output: "out", input: "v1" }],
         },
       ],
     });
@@ -184,7 +197,7 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(true);
+    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw new Error("Compilation error");
     });
@@ -197,7 +210,7 @@ describe("batchCompile", () => {
     );
     expect(mockConsoleError).toHaveBeenNthCalledWith(
       2,
-      'Sample: sample.yaml, Variant: {"output":"out","data":"v1"}',
+      'Sample: sample.yaml, Variant: {"output":"out","input":"v1"}',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -206,11 +219,11 @@ describe("batchCompile", () => {
     mockIsFile.mockReturnValue(true);
     mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
         {
           templatePath: "sample.yaml",
-          variants: [{ output: "out", data: "v1" }],
+          variants: [{ output: "out", input: "v1" }],
         },
       ],
     });
@@ -222,7 +235,7 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(true);
+    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw "Unknown error";
     });
@@ -239,13 +252,13 @@ describe("batchCompile", () => {
     mockIsFile.mockReturnValue(true);
     mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
         {
           templatePath: "sample.yaml",
           variants: [
-            { output: "v1.output", data: {} },
-            { output: "v2.output", data: {} },
+            { output: "v1.output", input: {} },
+            { output: "v2.output", input: {} },
           ],
           output: "out",
         },
@@ -259,7 +272,7 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(true);
+    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockReturnValue({
       items: [
         { fileName: "file1.js", content: "console.log('1');" },
@@ -269,8 +282,12 @@ describe("batchCompile", () => {
     mockCreateOutputDirectory.mockImplementation(() => {});
     mockFs.writeFileSync.mockImplementation(() => {});
     batchCompile("batch.yaml");
-    expect(mockCreateOutputDirectory).toHaveBeenCalledWith("/working/directory/v1.output");
-    expect(mockCreateOutputDirectory).toHaveBeenCalledWith("/working/directory/v2.output");
+    expect(mockCreateOutputDirectory).toHaveBeenCalledWith(
+      "/working/directory/v1.output",
+    );
+    expect(mockCreateOutputDirectory).toHaveBeenCalledWith(
+      "/working/directory/v2.output",
+    );
     expect(mockFs.writeFileSync).toHaveBeenCalledWith(
       path.join("/working/directory", "v1.output", "file1.js"),
       "console.log('1');",

package/test/common.test.ts

@@ -6,11 +6,7 @@ import fs from "fs";
 const mockFs = vi.mocked(fs);
 
 vi.mock("../src/utils");
-import {
-  parse,
-  resolveSampleFile,
-  isFile,
-} from "../src/utils";
+import { parse, resolveSampleFile, isFile } from "../src/utils";
 import { resolveAndParseSample } from "../src/common";
 const mockParse = vi.mocked(parse);
 const mockResolveSampleFile = vi.mocked(resolveSampleFile);