@lunatest/core 0.1.0

package/dist/scenario/index.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+declare const StageSchema: z.ZodObject<{
+    name: z.ZodString;
+    on: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ScenarioSchema: z.ZodObject<{
+    name: z.ZodString;
+    given: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    when: z.ZodObject<{
+        action: z.ZodString;
+    }, z.core.$loose>;
+    then_ui: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    then_state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    stages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        on: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    not_present: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timing_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type ScenarioStage = z.infer<typeof StageSchema>;
+export type ParsedScenario = z.infer<typeof ScenarioSchema>;
+export type StageMachine = {
+    current: () => ScenarioStage;
+    next: () => ScenarioStage;
+    done: () => boolean;
+    index: () => number;
+    path: () => string[];
+};
+export type VirtualClockEvent = {
+    atMs: number;
+    payload: Record<string, unknown>;
+};
+export type VirtualClock = {
+    now: () => number;
+    advance: (deltaMs: number) => number;
+    schedule: (afterMs: number, payload: Record<string, unknown>) => void;
+    drainDue: () => Record<string, unknown>[];
+};
+export declare function parseScenario(input: unknown): ParsedScenario;
+export declare function createStageMachine(stages: ScenarioStage[]): StageMachine;
+export declare function createVirtualClock(initialMs?: number): VirtualClock;
+export {};

package/dist/scenario/index.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+const RecordValueSchema = z.record(z.string(), z.unknown());
+const StageSchema = z.object({
+    name: z.string().min(1),
+    on: z.string().min(1).optional(),
+});
+const ScenarioSchema = z
+    .object({
+    name: z.string().min(1),
+    given: RecordValueSchema,
+    when: z
+        .object({
+        action: z.string().min(1),
+    })
+        .passthrough(),
+    then_ui: RecordValueSchema,
+    then_state: RecordValueSchema.optional(),
+    stages: z.array(StageSchema).optional(),
+    not_present: z.array(z.string().min(1)).optional(),
+    timing_ms: z.number().int().nonnegative().optional(),
+})
+    .passthrough();
+export function parseScenario(input) {
+    if (!input || typeof input !== "object" || !("given" in input)) {
+        throw new Error("given is required");
+    }
+    return ScenarioSchema.parse(input);
+}
+export function createStageMachine(stages) {
+    if (stages.length === 0) {
+        throw new Error("stages must contain at least one stage");
+    }
+    let cursor = 0;
+    const path = [stages[0].name];
+    return {
+        current() {
+            return stages[cursor];
+        },
+        next() {
+            if (cursor >= stages.length - 1) {
+                return stages[cursor];
+            }
+            cursor += 1;
+            path.push(stages[cursor].name);
+            return stages[cursor];
+        },
+        done() {
+            return cursor >= stages.length - 1;
+        },
+        index() {
+            return cursor;
+        },
+        path() {
+            return [...path];
+        },
+    };
+}
+export function createVirtualClock(initialMs = 0) {
+    let current = Math.max(0, Math.trunc(initialMs));
+    let queue = [];
+    const sortQueue = () => {
+        queue.sort((left, right) => left.atMs - right.atMs);
+    };
+    return {
+        now() {
+            return current;
+        },
+        advance(deltaMs) {
+            current += Math.max(0, Math.trunc(deltaMs));
+            return current;
+        },
+        schedule(afterMs, payload) {
+            queue.push({
+                atMs: current + Math.max(0, Math.trunc(afterMs)),
+                payload: { ...payload },
+            });
+            sortQueue();
+        },
+        drainDue() {
+            const due = queue.filter((event) => event.atMs <= current);
+            queue = queue.filter((event) => event.atMs > current);
+            return due.map((event) => ({ ...event.payload }));
+        },
+    };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@lunatest/core",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "dependencies": {
+    "wasmoon": "^1.16.0",
+    "zod": "^4.1.5",
+    "@lunatest/contracts": "0.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "fast-check": "^4.5.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  }
+}