@intentius/chant 0.1.4 → 0.1.6

package/src/composite.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach } from "bun:test";
+import { describe, test, expect, beforeEach } from "vitest";
 import {
   Composite,
   isCompositeInstance,
@@ -13,6 +13,7 @@ import {
 } from "./composite";
 import { DECLARABLE_MARKER, type Declarable } from "./declarable";
 import { AttrRef } from "./attrref";
+import { createResource } from "./runtime";
 
 function mockDeclarable(type = "TestEntity", lexicon = "test"): Declarable {
   return {
@@ -234,18 +235,18 @@ describe("resource() helper", () => {
 
   test("forwards attributes as second constructor argument", () => {
     // MockResource doesn't store attributes, so use createResource which does
-    const { createResource } = require("./runtime");
     const TestRes = createResource("Test::Resource", "test", { arn: "Arn" });
     const attrs = { DependsOn: ["Other"], Condition: "IsProd" };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const instance = resource(TestRes as any, { name: "test" }, attrs);
-    expect((instance as any).attributes).toEqual(attrs);
+    expect((instance as unknown as Record<string, unknown>).attributes).toEqual(attrs);
   });
 
   test("without attributes, resource() creates instance with empty attributes", () => {
-    const { createResource } = require("./runtime");
     const TestRes = createResource("Test::Resource", "test", { arn: "Arn" });
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const instance = resource(TestRes as any, { name: "test" });
-    expect((instance as any).attributes).toEqual({});
+    expect((instance as unknown as Record<string, unknown>).attributes).toEqual({});
   });
 });
 
@@ -410,8 +411,8 @@ describe("propagate", () => {
     const instance = propagate(MyComp({}), { env: "prod" });
     const expanded = expandComposite("s", instance);
 
-    const bucketProps = (expanded.get("sBucket") as any).props;
-    const roleProps = (expanded.get("sRole") as any).props;
+    const bucketProps = (expanded.get("sBucket") as unknown as Record<string, unknown>).props as Record<string, unknown>;
+    const roleProps = (expanded.get("sRole") as unknown as Record<string, unknown>).props as Record<string, unknown>;
     expect(bucketProps.env).toBe("prod");
     expect(roleProps.env).toBe("prod");
   });
@@ -427,7 +428,7 @@ describe("propagate", () => {
       tags: [{ key: "env", value: "prod" }],
     });
     const expanded = expandComposite("s", instance);
-    const tags = (expanded.get("sBucket") as any).props.tags;
+    const tags = ((expanded.get("sBucket") as unknown as Record<string, unknown>).props as Record<string, unknown>).tags;
 
     expect(tags).toEqual([
       { key: "env", value: "prod" },
@@ -442,7 +443,7 @@ describe("propagate", () => {
 
     const instance = propagate(MyComp({}), { region: "eu-west-1" });
     const expanded = expandComposite("s", instance);
-    expect((expanded.get("sBucket") as any).props.region).toBe("us-west-2");
+    expect(((expanded.get("sBucket") as unknown as Record<string, unknown>).props as Record<string, unknown>).region).toBe("us-west-2");
   });
 
   test("undefined values in shared props are stripped", () => {
@@ -452,7 +453,7 @@ describe("propagate", () => {
 
     const instance = propagate(MyComp({}), { name: undefined, extra: "yes" });
     const expanded = expandComposite("s", instance);
-    const props = (expanded.get("sBucket") as any).props;
+    const props = (expanded.get("sBucket") as unknown as Record<string, unknown>).props as Record<string, unknown>;
     expect(props.name).toBe("data");
     expect(props.extra).toBe("yes");
   });
@@ -470,8 +471,8 @@ describe("propagate", () => {
     const instance = propagate(Outer({}), { env: "prod" });
     const expanded = expandComposite("app", instance);
 
-    expect((expanded.get("appBucket") as any).props.env).toBe("prod");
-    expect((expanded.get("appNestedTable") as any).props.env).toBe("prod");
+    expect(((expanded.get("appBucket") as unknown as Record<string, unknown>).props as Record<string, unknown>).env).toBe("prod");
+    expect(((expanded.get("appNestedTable") as unknown as Record<string, unknown>).props as Record<string, unknown>).env).toBe("prod");
   });
 
   test("expanded declarables are same object references", () => {
@@ -489,7 +490,7 @@ describe("propagate", () => {
     }));
 
     const expanded = expandComposite("s", MyComp({}));
-    expect((expanded.get("sBucket") as any).props.name).toBe("data");
+    expect(((expanded.get("sBucket") as unknown as Record<string, unknown>).props as Record<string, unknown>).name).toBe("data");
   });
 });
 
@@ -523,10 +524,10 @@ describe("mergeDefaults", () => {
 
   test("object override deep merges nested objects", () => {
     const result = mergeDefaults(
-      { config: { a: 1, b: 2 } },
-      { config: { a: 10 } as any },
+      { config: { a: 1, b: 2 } } as Record<string, unknown>,
+      { config: { a: 10 } },
     );
-    expect(result.config).toEqual({ a: 10, b: 2 } as any);
+    expect(result["config"]).toEqual({ a: 10, b: 2 });
   });
 
   test("new keys from overrides are added", () => {

package/src/composite.ts

@@ -16,6 +16,7 @@ export type CompositeMembers = Record<string, Declarable>;
 export interface CompositeInstance<M extends CompositeMembers = CompositeMembers> {
   readonly [COMPOSITE_MARKER]: true;
   readonly members: M;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   readonly _definition: CompositeDefinition<any, M>;
 }
 
@@ -120,7 +121,7 @@ export function expandComposite(
   instance: CompositeInstance,
 ): Map<string, Declarable> {
   const result = new Map<string, Declarable>();
-  const shared = (instance as any)[SHARED_PROPS] as Record<string, unknown> | undefined;
+  const shared = (instance as unknown as Record<symbol, unknown>)[SHARED_PROPS] as Record<string, unknown> | undefined;
 
   for (const [memberName, member] of Object.entries(instance.members)) {
     const fullName = `${prefix}${memberName[0].toUpperCase()}${memberName.slice(1)}`;
@@ -265,17 +266,17 @@ export function mergeDefaults<T extends Record<string, unknown>>(
     if (value === undefined) continue;
     const existing = result[key as keyof T];
     if (Array.isArray(existing) && Array.isArray(value)) {
-      (result as any)[key] = [...existing, ...value];
+      (result as Record<string, unknown>)[key] =[...existing, ...value];
     } else if (
       existing != null && typeof existing === "object" && !Array.isArray(existing) &&
       value != null && typeof value === "object" && !Array.isArray(value)
     ) {
-      (result as any)[key] = mergeDefaults(
+      (result as Record<string, unknown>)[key] =mergeDefaults(
         existing as Record<string, unknown>,
         value as Record<string, unknown>,
       );
     } else {
-      (result as any)[key] = value;
+      (result as Record<string, unknown>)[key] =value;
     }
   }
   return result;

package/src/config.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { loadChantConfig, DEFAULT_CHANT_CONFIG } from "./config";
 import { writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
 
-const TEST_DIR = join(import.meta.dir, "__test_chant_config__");
+const TEST_DIR = join(import.meta.dirname, "__test_chant_config__");
 
 beforeEach(() => {
   mkdirSync(TEST_DIR, { recursive: true });
@@ -68,7 +68,7 @@ describe("loadChantConfig", () => {
     );
 
     const result = await loadChantConfig(TEST_DIR);
-    expect(result.configPath).toEndWith("chant.config.ts");
+    expect(result.configPath?.endsWith("chant.config.ts")).toBe(true);
   });
 
   test("handles empty config", async () => {

package/src/config.ts

@@ -7,7 +7,6 @@ import type { LintConfig } from "./lint/config";
  * Zod schema for ChantConfig validation.
  */
 export const ChantConfigSchema = z.object({
-  runtime: z.enum(["bun", "node"]).optional(),
   lexicons: z.array(z.string().min(1)).optional(),
   environments: z.array(z.string().min(1)).optional(),
   lint: z.record(z.string(), z.unknown()).optional(),
@@ -19,9 +18,6 @@ export const ChantConfigSchema = z.object({
  * Loaded from `chant.config.ts` (preferred) or `chant.config.json`.
  */
 export interface ChantConfig {
-  /** JS runtime to use for spawned commands: "bun" (default) or "node" */
-  runtime?: "bun" | "node";
-
   /** Lexicon package names to load (e.g. ["aws"]) */
   lexicons?: string[];
 

package/src/declarable.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import {
   DECLARABLE_MARKER,
   type Declarable,

package/src/detectLexicon.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { detectLexicons } from "./detectLexicon";
 import { mkdir, writeFile, rm } from "node:fs/promises";
 import { join } from "node:path";

package/src/discovery/cache.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { DiscoveryCache } from "./cache";
 import { writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";

package/src/discovery/collect.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach } from "bun:test";
+import { describe, test, expect, beforeEach } from "vitest";
 import { collectEntities } from "./collect";
 import { DECLARABLE_MARKER } from "../declarable";
 import { DiscoveryError } from "../errors";

package/src/discovery/cycles.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { detectCycles, normalizeCycleKey } from "./cycles";
 
 describe("detectCycles", () => {

package/src/discovery/files.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { findInfraFiles } from "./files";
 import { withTestDir } from "@intentius/chant-test-utils";
 import { mkdir, writeFile } from "node:fs/promises";

package/src/discovery/graph.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { buildDependencyGraph } from "./graph";
 import { DECLARABLE_MARKER, type Declarable } from "../declarable";
 import { AttrRef } from "../attrref";

package/src/discovery/import.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { importModule } from "./import";
 import { DiscoveryError } from "../errors";
 import { withTestDir, expectToThrow } from "@intentius/chant-test-utils";
@@ -28,8 +28,8 @@ describe("importModule", () => {
 
       const module = await importModule(filePath);
       expect(module.default).toBeDefined();
-      expect((module.default as any).name).toBe("test");
-      expect((module.default as any).value).toBe(123);
+      expect((module.default as Record<string, unknown>).name).toBe("test");
+      expect((module.default as Record<string, unknown>).value).toBe(123);
     });
   });
 
@@ -125,6 +125,7 @@ describe("importModule", () => {
 
       const module = await importModule(filePath);
       expect(module.MyClass).toBeDefined();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const instance = new (module.MyClass as any)(100);
       expect(instance.getValue()).toBe(100);
     });

package/src/discovery/index.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { discover } from "./index";
 import { mkdir, writeFile, rm } from "node:fs/promises";
 import { join } from "node:path";

package/src/discovery/resolve.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { resolveAttrRefs } from "./resolve";
 import { AttrRef } from "../attrref";
 import type { Declarable } from "../declarable";

package/src/errors.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { DiscoveryError, BuildError, LintError } from "./errors";
 
 describe("DiscoveryError", () => {

package/src/import/base-parser.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, test } from "vitest";
 import { BaseValueParser } from "./base-parser";
 
 /**

package/src/import/ir-utils.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, test } from "vitest";
 import { hasIntrinsicInValue, irUsesIntrinsic, collectDependencies } from "./ir-utils";
 import type { TemplateIR } from "./parser";
 

package/src/index.ts

@@ -61,3 +61,7 @@ export * from "./lsp/lexicon-providers";
 export * from "./mcp/types";
 export * from "./state/index";
 export * from "./spell/index";
+// Op builders — use explicit exports to avoid collision with the core `build` function
+export { Op, phase, activity, gate, kubectlApply, helmInstall, waitForStack,
+         gitlabPipeline, stateSnapshot, shell, teardown, OpResource } from "./op/index";
+export type { OpConfig, PhaseDefinition, StepDefinition, ActivityStep, GateStep, RetryPolicy } from "./op/index";

package/src/intrinsic-interpolation.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, test } from "vitest";
 import { buildInterpolatedString, defaultInterpolationSerializer } from "./intrinsic-interpolation";
 import { AttrRef } from "./attrref";
 import { INTRINSIC_MARKER } from "./intrinsic";

package/src/intrinsic.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { INTRINSIC_MARKER, resolveIntrinsicValue, isIntrinsic } from "./intrinsic";
 
 describe("resolveIntrinsicValue", () => {

package/src/lexicon-integrity.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { hashArtifact, computeIntegrity, verifyIntegrity, type ArtifactIntegrity } from "./lexicon-integrity";
 import type { BundleSpec } from "./lexicon";
 
@@ -35,7 +35,7 @@ function makeSpec(overrides?: Partial<BundleSpec>): BundleSpec {
 describe("computeIntegrity", () => {
   test("returns xxhash64 algorithm", () => {
     const integrity = computeIntegrity(makeSpec());
-    expect(integrity.algorithm).toBe("xxhash64");
+    expect(integrity.algorithm).toBe("sha256");
   });
 
   test("hashes all artifacts", () => {

package/src/lexicon-manifest.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { validateManifest } from "./lexicon-schema";
 import { checkVersionCompatibility } from "./lexicon-manifest";
 

package/src/lexicon-output.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { LexiconOutput, output, isLexiconOutput } from "./lexicon-output";
 import { AttrRef } from "./attrref";
 import { INTRINSIC_MARKER } from "./intrinsic";

package/src/lexicon-schema.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import {
   validateManifest,
   validateRegistry,

package/src/lint/config-overrides.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { loadConfig, resolveRulesForFile, type LintConfig } from "./config";
 import { writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
 
-const TEST_DIR = join(import.meta.dir, "__test_config_overrides__");
+const TEST_DIR = join(import.meta.dirname, "__test_config_overrides__");
 
 beforeEach(() => {
   mkdirSync(TEST_DIR, { recursive: true });

package/src/lint/config.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { loadConfig, DEFAULT_CONFIG } from "./config";
 import { writeFileSync, mkdirSync, rmSync } from "fs";
 import { join } from "path";
 
-const TEST_DIR = join(import.meta.dir, "__test_config__");
+const TEST_DIR = join(import.meta.dirname, "__test_config__");
 
 beforeEach(() => {
   // Create test directory

package/src/lint/config.ts

@@ -42,7 +42,7 @@ function isBadSeverityError(issue: z.ZodIssue, config: unknown, path: readonly (
   let value: unknown = config;
   for (const key of path) {
     if (value == null || typeof value !== "object") return null;
-    value = (value as any)[key];
+    value = (value as Record<string, unknown>)[key];
   }
 
   // If the value is a string, the user meant it as a severity — show the specific severity error

package/src/lint/declarative.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { rule } from "./declarative";
 import type { RuleSpec } from "./declarative";

package/src/lint/discover.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { discoverLintRules, discoverPostSynthChecks } from "./discover";

package/src/lint/discover.ts

@@ -11,6 +11,16 @@ import { createRequire } from "module";
 import type { LintRule } from "./rule";
 import type { PostSynthCheck } from "./post-synth";
 
+// Register tsx so createRequire can load TypeScript files in Node.js ESM context.
+// This is a no-op if tsx is not available or already registered.
+try {
+  const _req = createRequire(import.meta.url);
+  const { register } = _req("tsx/cjs/api") as { register: () => void };
+  register();
+} catch {
+  // tsx not available; only pre-compiled .js files can be require()'d
+}
+
 /**
  * Discover lint rules from a directory.
  *

package/src/lint/engine.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { runLint } from "./engine";
 import type { LintRule, LintContext, LintDiagnostic } from "./rule";
 import { withTestDir } from "@intentius/chant-test-utils";

package/src/lint/named-checks.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { registerCheck, getNamedCheck, listChecks } from "./named-checks";
 import type { LintContext } from "./rule";

package/src/lint/parser.test.ts

@@ -1,10 +1,10 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
 import { parseFile } from "./parser";
 import { writeFileSync, unlinkSync, mkdirSync } from "fs";
 import { join } from "path";
 import * as ts from "typescript";
 
-const TEST_DIR = join(import.meta.dir, "__test_parser__");
+const TEST_DIR = join(import.meta.dirname, "__test_parser__");
 const VALID_FILE = join(TEST_DIR, "valid.ts");
 const INVALID_FILE = join(TEST_DIR, "invalid.ts");
 const NONEXISTENT_FILE = join(TEST_DIR, "nonexistent.ts");

package/src/lint/post-synth.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { runPostSynthChecks } from "./post-synth";
 import type { PostSynthCheck, PostSynthContext } from "./post-synth";
 

package/src/lint/rule-loader.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
 import { mkdirSync, writeFileSync, rmSync, existsSync } from "fs";
 import { join } from "path";
 import { loadLocalRules } from "./rule-loader";
 
-const TEST_DIR = join(import.meta.dir, "__test_rules_fixture__");
+const TEST_DIR = join(import.meta.dirname, "__test_rules_fixture__");
 const RULES_DIR = join(TEST_DIR, ".chant", "rules");
 
 beforeAll(() => {

package/src/lint/rule-options.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { parseRuleConfig, loadConfig } from "./config";
 import { fileDeclarableLimitRule } from "./rules/file-declarable-limit";
 import * as ts from "typescript";
@@ -15,7 +15,7 @@ function makeNewExprs(names: string[]): string {
   return names.map((n) => `const x = new ${n}({ name: "a" });`).join("\n");
 }
 
-const TEST_DIR = join(import.meta.dir, "__test_rule_options__");
+const TEST_DIR = join(import.meta.dirname, "__test_rule_options__");
 
 beforeEach(() => {
   mkdirSync(TEST_DIR, { recursive: true });

package/src/lint/rule-registry.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { buildRuleRegistry } from "./rule-registry";
 import type { LintRule, LintContext, LintDiagnostic } from "./rule";
 import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "./post-synth";

package/src/lint/rule.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type {
   LintRule,
   LintContext,

package/src/lint/rules/cor017-composite-name-match.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { cor017CompositeNameMatchRule } from "./cor017-composite-name-match";
 import type { LintContext } from "../rule";

package/src/lint/rules/cor018-composite-prefer-lexicon-type.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { cor018CompositePreferLexiconTypeRule } from "./cor018-composite-prefer-lexicon-type";
 import type { LintContext } from "../rule";

package/src/lint/rules/declarable-naming-convention.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { declarableNamingConventionRule } from "./declarable-naming-convention";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl001-non-literal-expression.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl001NonLiteralExpressionRule } from "./evl001-non-literal-expression";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl002-control-flow-resource.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl002ControlFlowResourceRule } from "./evl002-control-flow-resource";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl003-dynamic-property-access.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl003DynamicPropertyAccessRule } from "./evl003-dynamic-property-access";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl004-spread-non-const.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl004SpreadNonConstRule } from "./evl004-spread-non-const";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl005-resource-block-body.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl005ResourceBlockBodyRule } from "./evl005-resource-block-body";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl007-invalid-siblings.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl007InvalidSiblingsRule } from "./evl007-invalid-siblings";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl009-composite-no-constant.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl009CompositeNoConstantRule } from "./evl009-composite-no-constant";
 import type { LintContext } from "../rule";

package/src/lint/rules/evl010-composite-no-transform.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl010CompositeNoTransformRule } from "./evl010-composite-no-transform";
 import type { LintContext } from "../rule";

package/src/lint/rules/export-required.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { exportRequiredRule } from "./export-required";
 import type { LintContext } from "../rule";

package/src/lint/rules/file-declarable-limit.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { fileDeclarableLimitRule } from "./file-declarable-limit";
 import type { LintContext } from "../rule";

package/src/lint/rules/flat-declarations.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { flatDeclarationsRule } from "./flat-declarations";
 import type { LintContext } from "../rule";

package/src/lint/rules/no-cyclic-declarable-ref.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { noCyclicDeclarableRefRule } from "./no-cyclic-declarable-ref";
 import type { LintContext } from "../rule";