@sleekcms/client 0.1.2 → 0.1.5

package/index.d.cts

@@ -0,0 +1,60 @@
+type Entry = Record<string, unknown>;
+type Page = {
+    _path: string;
+    [key: string]: unknown;
+};
+type Image = {
+    url: string;
+    [key: string]: unknown;
+};
+type List = Array<{
+    label: string;
+    value: string;
+}>;
+interface SleekSiteContent {
+    entries?: Record<string, Entry> | Record<string, Entry[]>;
+    pages?: Array<Page>;
+    images?: Record<string, Image>;
+    lists?: Record<string, List>;
+    config?: {
+        title?: string;
+    };
+}
+interface ClientOptions {
+    siteToken: string;
+    env?: string;
+    cache?: boolean;
+    mock?: boolean;
+    resolveEnv?: boolean;
+}
+
+/**
+ * Async SleekCMS client: methods return Promises.
+ */
+interface SleekClient {
+    getContent<T = SleekSiteContent>(query?: string): Promise<T>;
+    findPages<T = unknown>(path: string, query?: string): Promise<T>;
+    getImages(): Promise<SleekSiteContent["images"]>;
+    getImage(name: string): Promise<unknown | undefined>;
+    getList<T = unknown>(name: string): Promise<T[] | undefined>;
+}
+/**
+ * Sync client: prefetches full content once; subsequent calls are in-memory only.
+ */
+interface SleekSyncClient {
+    getContent<T = SleekSiteContent>(query?: string): T;
+    findPages<T = unknown>(path: string, query?: string): T;
+    getImages(): SleekSiteContent["images"];
+    getImage(name: string): unknown | undefined;
+    getList<T = unknown>(name: string): T[] | undefined;
+}
+declare function createClient(options: ClientOptions): SleekClient;
+/**
+ * Create a sync SleekCMS client.
+ *
+ * - Prefetches full content once (no search=).
+ * - All operations (including JMESPath) are local and synchronous.
+ */
+declare function createSyncClient(options: ClientOptions): Promise<SleekSyncClient>;
+
+export { type ClientOptions, type SleekClient, type SleekSiteContent, type SleekSyncClient, createClient, createSyncClient };

package/index.d.ts

@@ -0,0 +1,60 @@
+type Entry = Record<string, unknown>;
+type Page = {
+    _path: string;
+    [key: string]: unknown;
+};
+type Image = {
+    url: string;
+    [key: string]: unknown;
+};
+type List = Array<{
+    label: string;
+    value: string;
+}>;
+interface SleekSiteContent {
+    entries?: Record<string, Entry> | Record<string, Entry[]>;
+    pages?: Array<Page>;
+    images?: Record<string, Image>;
+    lists?: Record<string, List>;
+    config?: {
+        title?: string;
+    };
+}
+interface ClientOptions {
+    siteToken: string;
+    env?: string;
+    cache?: boolean;
+    mock?: boolean;
+    resolveEnv?: boolean;
+}
+
+/**
+ * Async SleekCMS client: methods return Promises.
+ */
+interface SleekClient {
+    getContent<T = SleekSiteContent>(query?: string): Promise<T>;
+    findPages<T = unknown>(path: string, query?: string): Promise<T>;
+    getImages(): Promise<SleekSiteContent["images"]>;
+    getImage(name: string): Promise<unknown | undefined>;
+    getList<T = unknown>(name: string): Promise<T[] | undefined>;
+}
+/**
+ * Sync client: prefetches full content once; subsequent calls are in-memory only.
+ */
+interface SleekSyncClient {
+    getContent<T = SleekSiteContent>(query?: string): T;
+    findPages<T = unknown>(path: string, query?: string): T;
+    getImages(): SleekSiteContent["images"];
+    getImage(name: string): unknown | undefined;
+    getList<T = unknown>(name: string): T[] | undefined;
+}
+declare function createClient(options: ClientOptions): SleekClient;
+/**
+ * Create a sync SleekCMS client.
+ *
+ * - Prefetches full content once (no search=).
+ * - All operations (including JMESPath) are local and synchronous.
+ */
+declare function createSyncClient(options: ClientOptions): Promise<SleekSyncClient>;
+
+export { type ClientOptions, type SleekClient, type SleekSiteContent, type SleekSyncClient, createClient, createSyncClient };

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "@sleekcms/client",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Official SleekCMS content client for Node 18+ and browser",
   "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
+  "main": "index.cjs",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "private": false,
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.cjs"
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "build": "npm run clean && tsup src/index.ts --dts --format esm,cjs && cp README.md dist/ && jq '.private = false | .files = [\"index.cjs\", \"index.mjs\", \"index.d.ts\", \"index.d.cts\", \"README.md\"]' package.json > dist/package.json",
     "clean": "rimraf dist || true",
     "test": "vitest run",
     "test:watch": "vitest",
-    "prepublishOnly": "npm run build"
+    "publish:dist": "cd dist && npm publish --access public"
   },
   "dependencies": {
     "jmespath": "^0.16.0"
@@ -34,5 +35,12 @@
     "tsup": "^8.5.1",
     "typescript": "^5.4.0",
     "vitest": "^4.0.15"
-  }
+  },
+  "files": [
+    "index.cjs",
+    "index.mjs",
+    "index.d.ts",
+    "index.d.cts",
+    "README.md"
+  ]
 }

package/__tests__/index.test.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createClient, createSyncClient } from "../src/index";
-import type { SleekSiteContent } from "../src/types";
-
-// Mock data
-const mockSiteContent: SleekSiteContent = {
-  pages: [
-    { _path: "/", title: "Home", published: true },
-    { _path: "/blog/post-1", title: "Post 1", published: true, category: "tech" },
-    { _path: "/blog/post-2", title: "Post 2", published: false, category: "tech" },
-    { _path: "/about", title: "About", published: true }
-  ],
-  images: {
-    logo: { url: "https://example.com/logo.png", width: 200, height: 100 },
-    hero: { url: "https://example.com/hero.jpg", width: 1200, height: 600 }
-  },
-  lists: {
-    categories: [
-      { label: "Technology", value: "tech" },
-      { label: "Business", value: "business" }
-    ]
-  },
-  config: {
-    title: "Test Site"
-  }
-};
-
-describe("SleekCMS Client", () => {
-  let fetchSpy: any;
-
-  beforeEach(() => {
-    fetchSpy = vi.spyOn(globalThis, "fetch");
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("Search Query Functionality", () => {
-    it("should send search query as URL parameter when query is provided", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ["Post 1", "Post 2"]
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123"
-      });
-
-      const result = await client.getContent('pages[?published == `true`]');
-
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-      const calledUrl = fetchSpy.mock.calls[0][0];
-      expect(calledUrl).toContain("search=");
-      expect(calledUrl).toContain('pages');
-      expect(calledUrl).toContain('published');
-    });
-
-    it("should apply JMESPath query on server-side with search parameter", async () => {
-      const filteredPages = [
-        { _path: "/", title: "Home", published: true },
-        { _path: "/about", title: "About", published: true }
-      ];
-
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => filteredPages
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123"
-      });
-
-      const result = await client.getContent('pages[?published == `true`]');
-
-      expect(result).toEqual(filteredPages);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("should apply local JMESPath query in cache mode", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: true
-      });
-
-      // First call to load cache
-      const allContent = await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      // Second call with query should use local cache
-      const pages = await client.getContent<any[]>('pages');
-      expect(fetchSpy).toHaveBeenCalledTimes(1); // No additional fetch
-      expect(pages).toHaveLength(4);
-      expect(pages).toEqual(mockSiteContent.pages);
-    });
-
-    it("should handle complex JMESPath queries with findPages", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: true
-      });
-
-      await client.getContent(); // Load cache
-
-      const result = await client.findPages(
-        "/blog",
-        "[?published == `true`].title"
-      );
-
-      expect(result).toEqual(["Post 1"]);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("Cache Behavior - Async Client", () => {
-    it("should fetch full content once when cache is true", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: true
-      });
-
-      // First call
-      const content1 = await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-      expect(content1).toEqual(mockSiteContent);
-
-      // Second call should use cache
-      const content2 = await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1); // No additional fetch
-      expect(content2).toEqual(mockSiteContent);
-    });
-
-    it("should use cached data for all methods after initial fetch", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: true
-      });
-
-      // Initial fetch
-      await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      // All subsequent calls should use cache
-      const images = await client.getImages();
-      expect(images).toEqual(mockSiteContent.images);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      const logo = await client.getImage("logo");
-      expect(logo).toEqual(mockSiteContent.images!.logo);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      const list = await client.getList("categories");
-      expect(list).toEqual(mockSiteContent.lists!.categories);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      const pages = await client.findPages("/blog");
-      expect(pages).toHaveLength(2);
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("should enable cache automatically with mock=true and dev token", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "dev-site123",
-        mock: true
-      });
-
-      // First call
-      await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      // Second call should use cache (auto-enabled due to mock + dev)
-      await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("should fetch on each call when cache is false and query is provided", async () => {
-      fetchSpy
-        .mockResolvedValueOnce({
-          ok: true,
-          json: async () => mockSiteContent.pages
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          json: async () => [{ _path: "/new", title: "New Page" }]
-        });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: false
-      });
-
-      const pages1 = await client.getContent('pages');
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-      expect(Array.isArray(pages1)).toBe(true);
-
-      const pages2 = await client.getContent('pages');
-      expect(fetchSpy).toHaveBeenCalledTimes(2); // New fetch
-      expect(pages2).toEqual([{ _path: "/new", title: "New Page" }]);
-    });
-
-    it("should enable caching after first getContent() call without query", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: false
-      });
-
-      // First call without query enables cache
-      await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      // Subsequent calls use cache
-      await client.getImages();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      await client.getList("categories");
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it("should apply JMESPath queries locally when cache is enabled", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: true
-      });
-
-      // Load cache
-      await client.getContent();
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      // Query should be applied locally
-      const publishedPages = await client.getContent<any[]>(
-        'pages[?published == `true`]'
-      );
-      expect(publishedPages).toHaveLength(3);
-      expect(publishedPages.every((p: any) => p.published === true)).toBe(true);
-      expect(fetchSpy).toHaveBeenCalledTimes(1); // No additional fetch
-    });
-
-    it("should handle concurrent requests with cache enabled", async () => {
-      fetchSpy.mockResolvedValue({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = createClient({
-        siteToken: "prod-site123",
-        cache: true
-      });
-
-      // Multiple concurrent requests - may fetch multiple times initially
-      // but should eventually use cache
-      const [content1, content2, content3] = await Promise.all([
-        client.getContent(),
-        client.getContent(),
-        client.getContent()
-      ]);
-
-      expect(content1).toEqual(mockSiteContent);
-      expect(content2).toEqual(mockSiteContent);
-      expect(content3).toEqual(mockSiteContent);
-    });
-  });
-
-  describe("Sync Client", () => {
-    it("should prefetch all content and work synchronously", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: true,
-        json: async () => mockSiteContent
-      });
-
-      const client = await createSyncClient({
-        siteToken: "prod-site123"
-      });
-
-      // Initial fetch during creation
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-
-      // All methods are synchronous and use cached data
-      const content = client.getContent();
-      expect(content).toEqual(mockSiteContent);
-
-      const images = client.getImages();
-      expect(images).toEqual(mockSiteContent.images);
-
-      const pages = client.findPages("/blog");
-      expect(pages).toHaveLength(2);
-
-      // Still only one fetch
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should throw error when siteToken is missing", async () => {
-      const client = createClient({
-        siteToken: ""
-      });
-
-      await expect(client.getContent()).rejects.toThrow(
-        "[SleekCMS] siteToken is required"
-      );
-    });
-
-    it("should handle HTTP errors gracefully", async () => {
-      fetchSpy.mockResolvedValueOnce({
-        ok: false,
-        status: 404,
-        statusText: "Not Found",
-        json: async () => ({ message: "Site not found" })
-      });
-
-      const client = createClient({
-        siteToken: "prod-invalid"
-      });
-
-      await expect(client.getContent()).rejects.toThrow(
-        "[SleekCMS] Request failed (404): Site not found"
-      );
-    });
-  });
-});

package/src/index.ts

@@ -1,260 +0,0 @@
-import * as jmespath from "jmespath";
-import type { SleekSiteContent, ClientOptions } from "./types";
-
-function isDevToken(token: string): boolean {
-  return token.startsWith("dev-");
-}
-
-function getBaseUrl(token: string): string {
-  let [env, siteId, ...rest] = token.split("-");
-  return `https://${env}.sleekcms.com/${siteId}`;
-}
-
-/**
- * Low-level fetch helper.
- * - If `searchQuery` is provided, it's sent as `?search=<JMESPath>`.
- * - If options.mock === true and token is dev-..., `mock=true` is added.
- */
-async function fetchSiteContent(
-  options: ClientOptions,
-  searchQuery?: string
-): Promise<any> {
-  const { siteToken, env = "latest", mock } = options;
-
-  if (!siteToken) {
-    throw new Error("[SleekCMS] siteToken is required");
-  }
-
-  const baseUrl = getBaseUrl(siteToken).replace(/\/$/, "");
-  const url = new URL(`${baseUrl}/${env}`);
-
-  if (searchQuery) {
-    url.searchParams.set("search", searchQuery);
-  }
-
-  if (mock && isDevToken(siteToken)) {
-    url.searchParams.set("mock", "true");
-  }
-
-  const res = await fetch(url.toString(), {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: siteToken
-    }
-  });
-
-  if (!res.ok) {
-    let message = res.statusText;
-    try {
-      const data = (await res.json()) as { message?: string };
-      if (data && data.message) message = data.message;
-    } catch {
-      // ignore
-    }
-    throw new Error(`[SleekCMS] Request failed (${res.status}): ${message}`);
-  }
-
-  return res.json();
-}
-
-function applyJmes<T = unknown>(data: unknown, query?: string): T {
-  if (!query) return data as T;
-  return jmespath.search(data, query) as T;
-}
-
-export type { SleekSiteContent, ClientOptions };
-
-/**
- * Async SleekCMS client: methods return Promises.
- */
-export interface SleekClient {
-  getContent<T = SleekSiteContent>(query?: string): Promise<T>;
-  findPages<T = unknown>(path: string, query?: string): Promise<T>;
-  getImages(): Promise<SleekSiteContent["images"]>;
-  getImage(name: string): Promise<unknown | undefined>;
-  getList<T = unknown>(name: string): Promise<T[] | undefined>;
-}
-
-/**
- * Sync client: prefetches full content once; subsequent calls are in-memory only.
- */
-export interface SleekSyncClient {
-  getContent<T = SleekSiteContent>(query?: string): T;
-  findPages<T = unknown>(path: string, query?: string): T;
-  getImages(): SleekSiteContent["images"];
-  getImage(name: string): unknown | undefined;
-  getList<T = unknown>(name: string): T[] | undefined;
-}
-
-export function createClient(options: ClientOptions): SleekClient {
-  const dev = isDevToken(options.siteToken);
-
-  let cacheMode = !!options.cache || (!!options.mock && dev);
-  let cachedContent: SleekSiteContent | null = null;
-
-  async function ensureCacheLoaded(): Promise<SleekSiteContent> {
-    if (cachedContent) return cachedContent;
-    const data = (await fetchSiteContent(options)) as SleekSiteContent;
-    cachedContent = data;
-    return data;
-  }
-
-  async function getContent<T = SleekSiteContent>(query?: string): Promise<T> {
-    if (cacheMode) {
-      const data = await ensureCacheLoaded();
-      return applyJmes<T>(data, query);
-    }
-
-    if (!query) {
-      const data = (await fetchSiteContent(options)) as SleekSiteContent;
-      cachedContent = data;
-      cacheMode = true;
-      return data as T;
-    }
-
-    const data = await fetchSiteContent(options, query);
-    return data as T;
-  }
-
-  async function findPages<T = unknown>(
-    path: string,
-    query?: string
-  ): Promise<T> {
-    if (!path) {
-      throw new Error("[SleekCMS] path is required for findPages");
-    }
-
-    if (cacheMode) {
-      const data = await ensureCacheLoaded();
-      const pages = data.pages ?? [];
-      const filtered = pages.filter((p) => {
-        const pth = typeof p._path === "string" ? p._path : "";
-        return pth.startsWith(path);
-      });
-      return applyJmes<T>(filtered, query);
-    }
-
-    const pages = (await fetchSiteContent(
-      options,
-      "pages"
-    )) as SleekSiteContent["pages"];
-
-    const filtered = (pages ?? []).filter((p) => {
-      const pth = typeof p._path === "string" ? p._path : "";
-      return pth.startsWith(path);
-    });
-
-    return applyJmes<T>(filtered, query);
-  }
-
-  async function getImages(): Promise<SleekSiteContent["images"]> {
-    if (cacheMode) {
-      const data = await ensureCacheLoaded();
-      return data.images ?? {};
-    }
-
-    const images = (await fetchSiteContent(
-      options,
-      "images"
-    )) as SleekSiteContent["images"];
-    return images ?? {};
-  }
-
-  async function getImage(name: string): Promise<unknown | undefined> {
-    if (!name) return undefined;
-
-    if (cacheMode) {
-      const data = await ensureCacheLoaded();
-      return data.images ? data.images[name] : undefined;
-    }
-
-    const images = (await fetchSiteContent(
-      options,
-      "images"
-    )) as SleekSiteContent["images"];
-    return images ? images[name] : undefined;
-  }
-
-  async function getList<T = unknown>(
-    name: string
-  ): Promise<T[] | undefined> {
-    if (!name) return undefined;
-
-    if (cacheMode) {
-      const data = await ensureCacheLoaded();
-      const lists = data.lists ?? {};
-      const list = lists[name];
-      return Array.isArray(list) ? (list as T[]) : undefined;
-    }
-
-    const lists = (await fetchSiteContent(
-      options,
-      "lists"
-    )) as SleekSiteContent["lists"];
-    const list = lists ? lists[name] : undefined;
-    return Array.isArray(list) ? (list as T[]) : undefined;
-  }
-
-  return {
-    getContent,
-    findPages,
-    getImages,
-    getImage,
-    getList
-  };
-}
-
-/**
- * Create a sync SleekCMS client.
- *
- * - Prefetches full content once (no search=).
- * - All operations (including JMESPath) are local and synchronous.
- */
-export async function createSyncClient(
-  options: ClientOptions
-): Promise<SleekSyncClient> {
-  const data = (await fetchSiteContent(options)) as SleekSiteContent;
-
-  function getContent<T = SleekSiteContent>(query?: string): T {
-    return applyJmes<T>(data, query);
-  }
-
-  function findPages<T = unknown>(path: string, query?: string): T {
-    if (!path) {
-      throw new Error("[SleekCMS] path is required for findPages");
-    }
-
-    const pages = data.pages ?? [];
-    const filtered = pages.filter((p) => {
-      const pth = typeof p._path === "string" ? p._path : "";
-      return pth.startsWith(path);
-    });
-
-    return applyJmes<T>(filtered, query);
-  }
-
-  function getImages(): SleekSiteContent["images"] {
-    return data.images ?? {};
-  }
-
-  function getImage(name: string): unknown | undefined {
-    if (!name) return undefined;
-    return data.images ? data.images[name] : undefined;
-  }
-
-  function getList<T = unknown>(name: string): T[] | undefined {
-    if (!name) return undefined;
-    const lists = data.lists ?? {};
-    const list = lists[name];
-    return Array.isArray(list) ? (list as T[]) : undefined;
-  }
-
-  return {
-    getContent,
-    findPages,
-    getImages,
-    getImage,
-    getList
-  };
-}

package/src/types.ts

@@ -1,20 +0,0 @@
-
-type Entry = Record<string, unknown>;
-type Page = { _path: string; [key: string]: unknown };
-type Image = { url: string; [key: string]: unknown };
-type List = Array<{ label: string; value: string }>;
-
-export interface SleekSiteContent {
-  entries?: Record<string, Entry> | Record<string, Entry[]>;
-  pages?: Array<Page>;
-  images?: Record<string, Image>;
-  lists?: Record<string, List>;
-  config?: { title?: string; };
-}
-
-export interface ClientOptions {
-  siteToken: string;
-  env?: string;
-  cache?: boolean;
-  mock?: boolean;
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: "node"
-  }
-});