@systemfsoftware/xstate-test 0.0.0-bootstrap.0 → 2.0.0-beta.2

package/dist/adapter-Dd4Go0U3.d.ts

@@ -0,0 +1,58 @@
+import { F as PropertyGeneratorKind, V as TestAdapter } from "./index-CSbyUxJr.js";
+import * as fc from "fast-check";
+/** @experimental */
+interface FastCheckGeneratorKind extends PropertyGeneratorKind {
+  readonly generator: fc.Arbitrary<this['target']>;
+}
+/** @experimental */
+interface FastCheckSchedulerOptions {
+  /**
+   * Wraps every task release, for integrations that need their own batching
+   * (React's `act`, for example).
+   */
+  readonly act?: (task: () => Promise<void>) => Promise<void>;
+}
+/**
+ * A replayable summary of the ordering a scheduled run took.
+ *
+ * @experimental
+ */
+interface FastCheckSchedulerReport {
+  /** Task ids in the order the scheduler released them. */
+  readonly ordering: readonly number[];
+  readonly tasks: readonly {
+    readonly taskId: number;
+    readonly label: string;
+    readonly schedulingType: 'promise' | 'function' | 'sequence';
+    readonly status: 'resolved' | 'rejected' | 'pending';
+  }[];
+}
+/** @experimental */
+interface FastCheckAdapterOptions extends Omit<fc.Parameters<unknown>, 'examples'> {
+  readonly maxCommands?: number;
+  readonly replayPath?: string;
+  /**
+   * Explores promise resolution orders with `fc.scheduler()`. Wrap the system
+   * under test with `withScheduledSut` (and a reference oracle with
+   * `withScheduledReference`) so its async boundaries are scheduled too.
+   */
+  readonly scheduler?: boolean | FastCheckSchedulerOptions;
+}
+/**
+ * Extracts the `replayPath` that fast-check embeds in a `fc.commands`
+ * counterexample so a failing run can be replayed deterministically.
+ *
+ * fast-check exposes no typed accessor for this: `CommandsArbitrary` builds a
+ * `CommandsIterable` whose `metadataForReplay()` returns the
+ * `replayPath="<path>"` fragment, and whose `toString()` appends that fragment
+ * inside a trailing `/* ... *\/` comment. Neither member is declared in
+ * `fast-check`'s public typings (checked against fast-check 4.9.0), so this
+ * helper is the single place that depends on that shape. It prefers
+ * `metadataForReplay()` and falls back to parsing `toString()`.
+ *
+ * @experimental
+ */
+declare function extractReplayPath(counterexample: unknown): string | undefined;
+/** @experimental */
+declare function fastCheckAdapter(options?: FastCheckAdapterOptions): TestAdapter<FastCheckGeneratorKind>;
+export { extractReplayPath as a, FastCheckSchedulerReport as i, FastCheckGeneratorKind as n, fastCheckAdapter as o, FastCheckSchedulerOptions as r, FastCheckAdapterOptions as t };

package/dist/effect-schema.d.ts

@@ -0,0 +1,28 @@
+import { n as FastCheckGeneratorKind } from "./adapter-Dd4Go0U3.js";
+import { G as TestEventGenerators } from "./index-CSbyUxJr.js";
+import { EventsFromSchemasOptions } from "./schema.js";
+import { AnyStateMachine, EventFrom, SnapshotFrom } from "@systemfsoftware/xstate";
+import * as fc from "fast-check";
+import * as Schema from "effect/Schema";
+/**
+ * Converts an Effect Schema into a native FastCheck arbitrary.
+ *
+ * @experimental
+ */
+export declare function fromEffectSchema<TSchema extends Schema.Top>(schema: TSchema): fc.Arbitrary<TSchema['Type']>;
+/**
+ * Converts a keyed payload-schema map for use by `propertyTest()`.
+ *
+ * @experimental
+ */
+export declare function fromEffectSchemas<TSchemas extends Readonly<Record<string, Schema.Top>>>(schemas: TSchemas): { [TKey in keyof TSchemas]: fc.Arbitrary<TSchemas[TKey]['Type']>; };
+/**
+ * Same as `eventsFromSchemas` from `@xstate/test`, with Effect Schema
+ * support registered.
+ *
+ * @experimental
+ */
+export declare const eventsFromSchemas: {
+  <TMachine extends AnyStateMachine>(options?: EventsFromSchemasOptions): (machine: TMachine) => TestEventGenerators<SnapshotFrom<TMachine>, EventFrom<TMachine>, FastCheckGeneratorKind>;
+  <TMachine extends AnyStateMachine>(machine: TMachine, options?: EventsFromSchemasOptions): TestEventGenerators<SnapshotFrom<TMachine>, EventFrom<TMachine>, FastCheckGeneratorKind>;
+};

package/dist/effect-schema.mjs

@@ -0,0 +1,40 @@
+import { eventsFromSchemas as eventsFromSchemas$1 } from "./schema.mjs";
+import { dual } from "effect/Function";
+import * as Effect from "effect/Effect";
+import * as fc from "fast-check";
+import * as Arbitrary from "effect/Arbitrary";
+// src/effect-schema.ts
+const effectConverter = (schema) => schema !== null && (typeof schema === "object" || typeof schema === "function") && typeof schema.ast === "object" ? fromEffectSchema(schema) : void 0;
+/**
+* Converts an Effect Schema into a native FastCheck arbitrary.
+*
+* @experimental
+*/
+function fromEffectSchema(schema) {
+	const arbitrary = Arbitrary.schema(schema);
+	return fc.integer().map((seed) => Effect.runSync(Arbitrary.sampleEffect(arbitrary, {
+		count: 1,
+		seed
+	}))[0]);
+}
+/**
+* Converts a keyed payload-schema map for use by `propertyTest()`.
+*
+* @experimental
+*/
+function fromEffectSchemas(schemas) {
+	return Object.fromEntries(Object.entries(schemas).map(([key, schema]) => [key, fromEffectSchema(schema)]));
+}
+/**
+* Same as `eventsFromSchemas` from `@xstate/test`, with Effect Schema
+* support registered.
+*
+* @experimental
+*/
+const eventsFromSchemas = dual((args) => args.length >= 2 || typeof args[0] === "object" && args[0] !== null && "transition" in args[0], function eventsFromSchemas(machine, options = {}) {
+	return eventsFromSchemas$1(machine, {
+		...options,
+		converters: [effectConverter, ...options.converters ?? []]
+	});
+});
+export { eventsFromSchemas, fromEffectSchema, fromEffectSchemas };

package/dist/finalizerError-DOptAIDs.mjs

@@ -0,0 +1,8 @@
+import { dual } from "effect/Function";
+import { Effect, Ref } from "effect";
+// src/engine/finalizerError.ts
+const ensuringFinalizerWins = dual(2, (body, finalizer) => Effect.gen(function* () {
+	const finalizerCause = yield* Ref.make(void 0);
+	return yield* Effect.ensuring(body, finalizer.pipe(Effect.tapCause((cause) => Ref.set(finalizerCause, cause)))).pipe(Effect.catchCause((bodyCause) => Effect.flatMap(Ref.get(finalizerCause), (captured) => Effect.failCause(captured ?? bodyCause))));
+}));
+export { ensuringFinalizerWins as t };