@ricsam/quickjs-test-environment 0.2.10 → 0.2.11

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/quickjs-test-environment",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "type": "commonjs"
 }

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/quickjs-test-environment",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "type": "module"
 }

package/dist/types/quickjs.d.ts

@@ -0,0 +1,280 @@
+/**
+ * QuickJS Global Type Definitions for @ricsam/quickjs-test-environment
+ *
+ * These types define the globals injected by setupTestEnvironment() into a QuickJS context.
+ * Use these types to typecheck user code that will run inside QuickJS.
+ *
+ * @example
+ * describe("Math operations", () => {
+ *   it("should add numbers", () => {
+ *     expect(1 + 1).toBe(2);
+ *   });
+ * });
+ */
+
+export {};
+
+declare global {
+  // ============================================
+  // Test Structure
+  // ============================================
+
+  /**
+   * Define a test suite.
+   *
+   * @param name - The name of the test suite
+   * @param fn - Function containing tests and nested suites
+   *
+   * @example
+   * describe("Calculator", () => {
+   *   it("adds numbers", () => {
+   *     expect(1 + 1).toBe(2);
+   *   });
+   * });
+   */
+  function describe(name: string, fn: () => void): void;
+
+  namespace describe {
+    /**
+     * Skip this suite and all its tests.
+     */
+    function skip(name: string, fn: () => void): void;
+
+    /**
+     * Only run this suite (and other .only suites).
+     */
+    function only(name: string, fn: () => void): void;
+
+    /**
+     * Mark suite as todo (skipped with different status).
+     */
+    function todo(name: string, fn?: () => void): void;
+  }
+
+  /**
+   * Define a test case.
+   *
+   * @param name - The name of the test
+   * @param fn - The test function (can be async)
+   *
+   * @example
+   * it("should work", () => {
+   *   expect(true).toBe(true);
+   * });
+   *
+   * it("should work async", async () => {
+   *   const result = await Promise.resolve(42);
+   *   expect(result).toBe(42);
+   * });
+   */
+  function it(name: string, fn: () => void | Promise<void>): void;
+
+  namespace it {
+    /**
+     * Skip this test.
+     */
+    function skip(name: string, fn?: () => void | Promise<void>): void;
+
+    /**
+     * Only run this test (and other .only tests).
+     */
+    function only(name: string, fn: () => void | Promise<void>): void;
+
+    /**
+     * Mark test as todo.
+     */
+    function todo(name: string, fn?: () => void | Promise<void>): void;
+  }
+
+  /**
+   * Alias for it().
+   */
+  function test(name: string, fn: () => void | Promise<void>): void;
+
+  namespace test {
+    /**
+     * Skip this test.
+     */
+    function skip(name: string, fn?: () => void | Promise<void>): void;
+
+    /**
+     * Only run this test (and other .only tests).
+     */
+    function only(name: string, fn: () => void | Promise<void>): void;
+
+    /**
+     * Mark test as todo.
+     */
+    function todo(name: string, fn?: () => void | Promise<void>): void;
+  }
+
+  // ============================================
+  // Lifecycle Hooks
+  // ============================================
+
+  /**
+   * Run once before all tests in the current suite.
+   *
+   * @param fn - Setup function (can be async)
+   */
+  function beforeAll(fn: () => void | Promise<void>): void;
+
+  /**
+   * Run once after all tests in the current suite.
+   *
+   * @param fn - Teardown function (can be async)
+   */
+  function afterAll(fn: () => void | Promise<void>): void;
+
+  /**
+   * Run before each test in the current suite (and nested suites).
+   *
+   * @param fn - Setup function (can be async)
+   */
+  function beforeEach(fn: () => void | Promise<void>): void;
+
+  /**
+   * Run after each test in the current suite (and nested suites).
+   *
+   * @param fn - Teardown function (can be async)
+   */
+  function afterEach(fn: () => void | Promise<void>): void;
+
+  // ============================================
+  // Assertions
+  // ============================================
+
+  /**
+   * Matchers for assertions.
+   */
+  interface Matchers<T> {
+    /**
+     * Strict equality (===).
+     */
+    toBe(expected: T): void;
+
+    /**
+     * Deep equality.
+     */
+    toEqual(expected: unknown): void;
+
+    /**
+     * Deep equality with type checking.
+     */
+    toStrictEqual(expected: unknown): void;
+
+    /**
+     * Check if value is truthy.
+     */
+    toBeTruthy(): void;
+
+    /**
+     * Check if value is falsy.
+     */
+    toBeFalsy(): void;
+
+    /**
+     * Check if value is null.
+     */
+    toBeNull(): void;
+
+    /**
+     * Check if value is undefined.
+     */
+    toBeUndefined(): void;
+
+    /**
+     * Check if value is defined (not undefined).
+     */
+    toBeDefined(): void;
+
+    /**
+     * Check if value is NaN.
+     */
+    toBeNaN(): void;
+
+    /**
+     * Check if number is greater than expected.
+     */
+    toBeGreaterThan(n: number): void;
+
+    /**
+     * Check if number is greater than or equal to expected.
+     */
+    toBeGreaterThanOrEqual(n: number): void;
+
+    /**
+     * Check if number is less than expected.
+     */
+    toBeLessThan(n: number): void;
+
+    /**
+     * Check if number is less than or equal to expected.
+     */
+    toBeLessThanOrEqual(n: number): void;
+
+    /**
+     * Check if array/string contains item/substring.
+     */
+    toContain(item: unknown): void;
+
+    /**
+     * Check length of array/string.
+     */
+    toHaveLength(length: number): void;
+
+    /**
+     * Check if object has property (optionally with value).
+     */
+    toHaveProperty(key: string, value?: unknown): void;
+
+    /**
+     * Check if function throws.
+     */
+    toThrow(expected?: string | RegExp | Error): void;
+
+    /**
+     * Check if string matches pattern.
+     */
+    toMatch(pattern: string | RegExp): void;
+
+    /**
+     * Check if object matches subset of properties.
+     */
+    toMatchObject(object: object): void;
+
+    /**
+     * Check if value is instance of class.
+     */
+    toBeInstanceOf(constructor: Function): void;
+
+    /**
+     * Negate the matcher.
+     */
+    not: Matchers<T>;
+
+    /**
+     * Await promise and check resolved value.
+     */
+    resolves: Matchers<Awaited<T>>;
+
+    /**
+     * Await promise and check rejection.
+     */
+    rejects: Matchers<unknown>;
+  }
+
+  /**
+   * Create an expectation for a value.
+   *
+   * @param actual - The value to test
+   * @returns Matchers for the value
+   *
+   * @example
+   * expect(1 + 1).toBe(2);
+   * expect({ a: 1 }).toEqual({ a: 1 });
+   * expect(() => { throw new Error(); }).toThrow();
+   * expect(promise).resolves.toBe(42);
+   */
+  function expect<T>(actual: T): Matchers<T>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/quickjs-test-environment",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "Test environment for QuickJS with Bun/Jest/Vitest-compatible primitives",
   "main": "./dist/cjs/index.cjs",
   "types": "./dist/types/index.d.ts",
@@ -9,6 +9,9 @@
       "types": "./dist/types/index.d.ts",
       "require": "./dist/cjs/index.cjs",
       "import": "./dist/mjs/index.mjs"
+    },
+    "./quickjs": {
+      "types": "./dist/types/quickjs.d.ts"
     }
   },
   "scripts": {
@@ -19,7 +22,7 @@
     "quickjs-emscripten": ">=0.31.0"
   },
   "dependencies": {
-    "@ricsam/quickjs-core": "^0.2.10"
+    "@ricsam/quickjs-core": "^0.2.11"
   },
   "author": "Richard Samuelsson",
   "license": "MIT",