foldkit 0.43.1 → 0.44.0

package/dist/test/apps/login.d.ts

@@ -0,0 +1,46 @@
+import { Schema as S } from 'effect';
+import * as Command from '../../command';
+import { type Html } from '../../html';
+export declare const Model: S.Struct<{
+    email: typeof S.String;
+    password: typeof S.String;
+    status: S.Literal<["Idle", "Submitting", "LoggedIn", "Error"]>;
+    username: typeof S.String;
+    error: typeof S.String;
+}>;
+export type Model = typeof Model.Type;
+export declare const UpdatedEmail: import("../../schema").CallableTaggedStruct<"UpdatedEmail", {
+    value: typeof S.String;
+}>;
+export declare const UpdatedPassword: import("../../schema").CallableTaggedStruct<"UpdatedPassword", {
+    value: typeof S.String;
+}>;
+export declare const SubmittedLogin: import("../../schema").CallableTaggedStruct<"SubmittedLogin", {}>;
+export declare const SucceededAuthenticate: import("../../schema").CallableTaggedStruct<"SucceededAuthenticate", {
+    username: typeof S.String;
+}>;
+export declare const FailedAuthenticate: import("../../schema").CallableTaggedStruct<"FailedAuthenticate", {
+    error: typeof S.String;
+}>;
+export declare const ClickedLogout: import("../../schema").CallableTaggedStruct<"ClickedLogout", {}>;
+export declare const Message: S.Union<[import("../../schema").CallableTaggedStruct<"UpdatedEmail", {
+    value: typeof S.String;
+}>, import("../../schema").CallableTaggedStruct<"UpdatedPassword", {
+    value: typeof S.String;
+}>, import("../../schema").CallableTaggedStruct<"SubmittedLogin", {}>, import("../../schema").CallableTaggedStruct<"SucceededAuthenticate", {
+    username: typeof S.String;
+}>, import("../../schema").CallableTaggedStruct<"FailedAuthenticate", {
+    error: typeof S.String;
+}>, import("../../schema").CallableTaggedStruct<"ClickedLogout", {}>]>;
+export type Message = typeof Message.Type;
+export declare const Authenticate: Command.CommandDefinition<"Authenticate", {
+    readonly _tag: "SucceededAuthenticate";
+    readonly username: string;
+} | {
+    readonly _tag: "FailedAuthenticate";
+    readonly error: string;
+}>;
+export declare const initialModel: Model;
+export declare const update: (model: Model, message: Message) => readonly [Model, ReadonlyArray<Command.Command<Message>>];
+export declare const view: (model: Model) => Html;
+//# sourceMappingURL=login.d.ts.map

package/dist/test/apps/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/test/apps/login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAExD,OAAO,KAAK,OAAO,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,KAAK,IAAI,EAAQ,MAAM,YAAY,CAAA;AAK5C,eAAO,MAAM,KAAK;;;;;;EAMhB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAIrC,eAAO,MAAM,YAAY;;EAAyC,CAAA;AAClE,eAAO,MAAM,eAAe;;EAA4C,CAAA;AACxE,eAAO,MAAM,cAAc,mEAAsB,CAAA;AACjD,eAAO,MAAM,qBAAqB;;EAEhC,CAAA;AACF,eAAO,MAAM,kBAAkB;;EAA+C,CAAA;AAC9E,eAAO,MAAM,aAAa,kEAAqB,CAAA;AAE/C,eAAO,MAAM,OAAO;;;;;;;;sEAOnB,CAAA;AACD,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAIzC,eAAO,MAAM,YAAY;;;;;;EAIxB,CAAA;AAQD,eAAO,MAAM,YAAY,EAAE,KAM1B,CAAA;AAID,eAAO,MAAM,MAAM,GACjB,OAAO,KAAK,EACZ,SAAS,OAAO,KACf,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAyBxD,CAAA;AA2BH,eAAO,MAAM,IAAI,GAAI,OAAO,KAAK,KAAG,IAkEjC,CAAA"}

package/dist/test/apps/login.js

@@ -0,0 +1,83 @@
+import { Effect, Match as M, Schema as S } from 'effect';
+import * as Command from '../../command';
+import { html } from '../../html';
+import { m } from '../../message';
+// MODEL
+export const Model = S.Struct({
+    email: S.String,
+    password: S.String,
+    status: S.Literal('Idle', 'Submitting', 'LoggedIn', 'Error'),
+    username: S.String,
+    error: S.String,
+});
+// MESSAGE
+export const UpdatedEmail = m('UpdatedEmail', { value: S.String });
+export const UpdatedPassword = m('UpdatedPassword', { value: S.String });
+export const SubmittedLogin = m('SubmittedLogin');
+export const SucceededAuthenticate = m('SucceededAuthenticate', {
+    username: S.String,
+});
+export const FailedAuthenticate = m('FailedAuthenticate', { error: S.String });
+export const ClickedLogout = m('ClickedLogout');
+export const Message = S.Union(UpdatedEmail, UpdatedPassword, SubmittedLogin, SucceededAuthenticate, FailedAuthenticate, ClickedLogout);
+// COMMAND
+export const Authenticate = Command.define('Authenticate', SucceededAuthenticate, FailedAuthenticate);
+const authenticate = Authenticate(Effect.sync(() => SucceededAuthenticate({ username: 'alice' })));
+// INIT
+export const initialModel = {
+    email: '',
+    password: '',
+    status: 'Idle',
+    username: '',
+    error: '',
+};
+// UPDATE
+export const update = (model, message) => M.value(message).pipe(M.withReturnType(), M.tagsExhaustive({
+    UpdatedEmail: ({ value }) => [{ ...model, email: value }, []],
+    UpdatedPassword: ({ value }) => [{ ...model, password: value }, []],
+    SubmittedLogin: () => [
+        { ...model, status: 'Submitting' },
+        [authenticate],
+    ],
+    SucceededAuthenticate: ({ username }) => [
+        { ...model, status: 'LoggedIn', username },
+        [],
+    ],
+    FailedAuthenticate: ({ error }) => [
+        { ...model, status: 'Error', error },
+        [],
+    ],
+    ClickedLogout: () => [
+        { ...model, status: 'Idle', username: '', email: '', password: '' },
+        [],
+    ],
+}));
+// VIEW
+const { div, form, input, button, span, label, p, OnInput, OnSubmit, OnClick, Id, For, Class, Type, Value, Placeholder, Role, AriaExpanded, AriaLabel, Disabled, } = html();
+export const view = (model) => div([Id('app')], [
+    M.value(model.status).pipe(M.withReturnType(), M.when('Submitting', () => form([Class('login-form'), Disabled(true)], [button([Type('submit'), Disabled(true)], ['Signing in...'])])), M.when('LoggedIn', () => div([Class('logged-in'), Role('region'), AriaLabel('User session')], [
+        span([Class('greeting'), Role('status')], [`Welcome, ${model.username}!`]),
+        button([OnClick(ClickedLogout()), Role('button'), AriaExpanded(false)], ['Log out']),
+    ])), M.when('Error', () => div([], [
+        p([Class('error'), Role('alert')], [model.error]),
+        button([OnClick(SubmittedLogin()), Class('retry')], ['Retry']),
+    ])), M.when('Idle', () => form([OnSubmit(SubmittedLogin()), Class('login-form')], [
+        label([For('email'), Class('sr-only')], ['Email']),
+        input([
+            Id('email'),
+            Type('email'),
+            Placeholder('Email'),
+            Value(model.email),
+            OnInput(value => UpdatedEmail({ value })),
+        ]),
+        label([For('password'), Class('sr-only')], ['Password']),
+        input([
+            Id('password'),
+            Type('password'),
+            Placeholder('Password'),
+            Value(model.password),
+            OnInput(value => UpdatedPassword({ value })),
+        ]),
+        button([Type('submit'), Class('primary'), Disabled(false)], ['Sign in']),
+    ])), M.exhaustive),
+]);

package/dist/test/apps/logoutButton.d.ts

@@ -0,0 +1,17 @@
+import { Option, Schema as S } from 'effect';
+import type { Html } from '../../html';
+export declare const Model: S.Struct<{
+    label: typeof S.String;
+}>;
+export type Model = typeof Model.Type;
+export declare const ClickedLogout: import("../../schema").CallableTaggedStruct<"ClickedLogout", {}>;
+export declare const CompletedAction: import("../../schema").CallableTaggedStruct<"CompletedAction", {}>;
+export declare const Message: S.Union<[import("../../schema").CallableTaggedStruct<"ClickedLogout", {}>, import("../../schema").CallableTaggedStruct<"CompletedAction", {}>]>;
+export type Message = typeof Message.Type;
+export declare const RequestedLogout: import("../../schema").CallableTaggedStruct<"RequestedLogout", {}>;
+export declare const OutMessage: import("../../schema").CallableTaggedStruct<"RequestedLogout", {}>;
+export type OutMessage = typeof OutMessage.Type;
+export declare const initialModel: Model;
+export declare const update: (model: Model, message: Message) => readonly [Model, ReadonlyArray<never>, Option.Option<OutMessage>];
+export declare const view: (model: Model) => Html;
+//# sourceMappingURL=logoutButton.d.ts.map

package/dist/test/apps/logoutButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logoutButton.d.ts","sourceRoot":"","sources":["../../../src/test/apps/logoutButton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,QAAQ,CAAA;AAExD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAMtC,eAAO,MAAM,KAAK;;EAAgC,CAAA;AAClD,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAIrC,eAAO,MAAM,aAAa,kEAAqB,CAAA;AAC/C,eAAO,MAAM,eAAe,oEAAuB,CAAA;AAEnD,eAAO,MAAM,OAAO,iJAA0C,CAAA;AAC9D,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAIzC,eAAO,MAAM,eAAe,oEAAuB,CAAA;AAEnD,eAAO,MAAM,UAAU,oEAA2B,CAAA;AAClD,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAI/C,eAAO,MAAM,YAAY,EAAE,KAA4B,CAAA;AAIvD,eAAO,MAAM,MAAM,GACjB,OAAO,KAAK,EACZ,SAAS,OAAO,KACf,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAShE,CAAA;AAMH,eAAO,MAAM,IAAI,GAAI,OAAO,KAAK,KAAG,IAC0C,CAAA"}

package/dist/test/apps/logoutButton.js

@@ -0,0 +1,22 @@
+import { Match as M, Option, Schema as S } from 'effect';
+import { html } from '../../html';
+import { m } from '../../message';
+// MODEL
+export const Model = S.Struct({ label: S.String });
+// MESSAGE
+export const ClickedLogout = m('ClickedLogout');
+export const CompletedAction = m('CompletedAction');
+export const Message = S.Union(ClickedLogout, CompletedAction);
+// OUT MESSAGE
+export const RequestedLogout = m('RequestedLogout');
+export const OutMessage = S.Union(RequestedLogout);
+// INIT
+export const initialModel = { label: 'Log out' };
+// UPDATE
+export const update = (model, message) => M.value(message).pipe(M.withReturnType(), M.tagsExhaustive({
+    ClickedLogout: () => [model, [], Option.some(RequestedLogout())],
+    CompletedAction: () => [model, [], Option.none()],
+}));
+// VIEW
+const { div, button, OnClick, Role } = html();
+export const view = (model) => div([], [button([OnClick(ClickedLogout()), Role('button')], [model.label])]);

package/dist/test/internal.d.ts

@@ -0,0 +1,25 @@
+import type { CommandDefinition } from '../command';
+/** A Command in a test simulation, identified by name. */
+export type AnyCommand = Readonly<{
+    name: string;
+}>;
+type UpdateResult<Model, OutMessage> = readonly [Model, ReadonlyArray<AnyCommand>] | readonly [Model, ReadonlyArray<AnyCommand>, OutMessage];
+/** A Command definition paired with the result Message to resolve it with. */
+export type ResolverPair<Name extends string = string, ResultMessage = unknown> = readonly [CommandDefinition<Name, ResultMessage>, ResultMessage];
+/** Base shape of an internal simulation — shared between Story and Scene. */
+export type BaseInternal<Model, Message, OutMessage = undefined> = Readonly<{
+    model: Model;
+    message: Message | undefined;
+    commands: ReadonlyArray<AnyCommand>;
+    outMessage: OutMessage;
+    updateFn: (model: Model, message: Message) => UpdateResult<Model, OutMessage>;
+    resolvers: Record<string, Message>;
+}>;
+/** Resolves a single command by name and feeds its result through update. */
+export declare const resolveByName: <Model, Message>(internal: BaseInternal<Model, Message, unknown>, commandName: string, resolverMessage: Message) => BaseInternal<Model, Message, unknown> | undefined;
+/** Throws when trying to send a message with unresolved Commands. */
+export declare const assertNoUnresolvedCommands: (commands: ReadonlyArray<AnyCommand>, context: string) => void;
+/** Throws when Commands remain at the end of a test. */
+export declare const assertAllCommandsResolved: (commands: ReadonlyArray<AnyCommand>) => void;
+export {};
+//# sourceMappingURL=internal.d.ts.map

package/dist/test/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../src/test/internal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,0DAA0D;AAC1D,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAEnD,KAAK,YAAY,CAAC,KAAK,EAAE,UAAU,IAC/B,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC,GAC3C,SAAS,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC,CAAA;AAE3D,8EAA8E;AAC9E,MAAM,MAAM,YAAY,CACtB,IAAI,SAAS,MAAM,GAAG,MAAM,EAC5B,aAAa,GAAG,OAAO,IACrB,SAAS,CAAC,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,EAAE,aAAa,CAAC,CAAA;AAEpE,6EAA6E;AAC7E,MAAM,MAAM,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,GAAG,SAAS,IAAI,QAAQ,CAAC;IAC1E,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IACnC,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,KAAK,YAAY,CAAC,KAAK,EAAE,UAAU,CAAC,CAAA;IAC7E,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,CAAC,CAAA;AAEF,6EAA6E;AAC7E,eAAO,MAAM,aAAa,GAAI,KAAK,EAAE,OAAO,EAC1C,UAAU,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAC/C,aAAa,MAAM,EACnB,iBAAiB,OAAO,KACvB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,SAyBxC,CAAA;AAEH,qEAAqE;AACrE,eAAO,MAAM,0BAA0B,GACrC,UAAU,aAAa,CAAC,UAAU,CAAC,EACnC,SAAS,MAAM,KACd,IAcF,CAAA;AAED,wDAAwD;AACxD,eAAO,MAAM,yBAAyB,GACpC,UAAU,aAAa,CAAC,UAAU,CAAC,KAClC,IAcF,CAAA"}

package/dist/test/internal.js

@@ -0,0 +1,39 @@
+import { Array, Option, pipe } from 'effect';
+/** Resolves a single command by name and feeds its result through update. */
+export const resolveByName = (internal, commandName, resolverMessage) => pipe(internal.commands, Array.findFirstIndex(({ name }) => name === commandName), Option.match({
+    onNone: () => undefined,
+    onSome: commandIndex => {
+        const remainingCommands = Array.remove(internal.commands, commandIndex);
+        const [nextModel, newCommands, ...rest] = internal.updateFn(internal.model, resolverMessage);
+        const outMessage = Array.isNonEmptyArray(rest)
+            ? rest[0]
+            : internal.outMessage;
+        return {
+            ...internal,
+            model: nextModel,
+            message: resolverMessage,
+            commands: Array.appendAll(remainingCommands, newCommands),
+            outMessage,
+        };
+    },
+}));
+/** Throws when trying to send a message with unresolved Commands. */
+export const assertNoUnresolvedCommands = (commands, context) => {
+    if (Array.isNonEmptyReadonlyArray(commands)) {
+        const names = pipe(commands, Array.map(({ name }) => `    ${name}`), Array.join('\n'));
+        throw new Error(`I found unresolved Commands ${context}:\n\n${names}\n\n` +
+            'Resolve all Commands before sending the next Message.\n' +
+            'Use resolve(Definition, ResultMessage) for each one,\n' +
+            'or resolveAll([...pairs]) to resolve them all at once.');
+    }
+};
+/** Throws when Commands remain at the end of a test. */
+export const assertAllCommandsResolved = (commands) => {
+    if (Array.isNonEmptyReadonlyArray(commands)) {
+        const names = pipe(commands, Array.map(({ name }) => `    ${name}`), Array.join('\n'));
+        throw new Error(`I found Commands without resolvers:\n\n${names}\n\n` +
+            'Every Command produced by update needs to be resolved.\n' +
+            'Use resolve(Definition, ResultMessage) for each one,\n' +
+            'or resolveAll([...pairs]) to resolve them all at once.');
+    }
+};

package/dist/test/matchers.d.ts

@@ -0,0 +1,94 @@
+import { Option } from 'effect';
+import type { VNode } from '../vdom';
+/** Custom Vitest matchers for scene testing. Register with `expect.extend(Scene.sceneMatchers)`. */
+export declare const sceneMatchers: {
+    toHaveText(received: Option.Option<VNode>, expected: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toContainText(received: Option.Option<VNode>, expected: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toHaveClass(received: Option.Option<VNode>, expected: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toHaveAttr(received: Option.Option<VNode>, name: string, expectedValue?: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toExist(received: Option.Option<VNode>): {
+        pass: boolean;
+        message: () => "Expected element not to exist but it does." | "Expected element to exist but it does not.";
+    };
+    toBeAbsent(received: Option.Option<VNode>): {
+        pass: boolean;
+        message: () => "Expected element not to be absent but it is." | "Expected element to be absent but it exists.";
+    };
+    toHaveStyle(received: Option.Option<VNode>, name: string, expectedValue?: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toHaveHook(received: Option.Option<VNode>, name: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toHaveHandler(received: Option.Option<VNode>, name: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toHaveValue(received: Option.Option<VNode>, expected: string): {
+        pass: boolean;
+        message: () => string;
+    } | {
+        pass: false;
+        message: () => string;
+    } | {
+        pass: boolean;
+        message: () => string;
+    };
+    toBeDisabled(received: Option.Option<VNode>): {
+        pass: boolean;
+        message: () => "Expected element to be disabled but the element does not exist.";
+    } | {
+        pass: boolean;
+        message: () => "Expected element not to be disabled but it is." | "Expected element to be disabled but it is not.";
+    };
+    toBeEnabled(received: Option.Option<VNode>): {
+        pass: boolean;
+        message: () => "Expected element to be enabled but the element does not exist.";
+    } | {
+        pass: boolean;
+        message: () => "Expected element not to be enabled but it is." | "Expected element to be enabled but it is disabled.";
+    };
+    toBeChecked(received: Option.Option<VNode>): {
+        pass: boolean;
+        message: () => "Expected element to be checked but the element does not exist.";
+    } | {
+        pass: boolean;
+        message: () => "Expected element not to be checked but it is." | "Expected element to be checked but it is not.";
+    };
+};
+//# sourceMappingURL=matchers.d.ts.map

package/dist/test/matchers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchers.d.ts","sourceRoot":"","sources":["../../src/test/matchers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAKpC,oGAAoG;AACpG,eAAO,MAAM,aAAa;yBACH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,MAAM;;;;;;;4BAqBnC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,MAAM;;;;;;;0BAqBxC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,MAAM;;;;;;;yBAmBhD,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,QACxB,MAAM,kBACI,MAAM;;;;;;;sBA2CN,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;;;;yBAWjB,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;;;;0BAY7B,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,QACxB,MAAM,kBACI,MAAM;;;;;;;yBA8CH,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,MAAM;;;;;;;4BAsB/B,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,MAAM;;;;;;;0BAkBpC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,MAAM;;;;;;;;;;2BA4BrC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;;;;;;;0BAyBrB,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;;;;;;;0BAyBpB,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;;;;;;;CAwB3C,CAAA"}

package/dist/test/matchers.js

@@ -0,0 +1,283 @@
+import { Option } from 'effect';
+import { attr, textContent } from './query';
+/** Custom Vitest matchers for scene testing. Register with `expect.extend(Scene.sceneMatchers)`. */
+export const sceneMatchers = {
+    toHaveText(received, expected) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => `Expected element to have text "${expected}" but the element does not exist.`,
+            }),
+            onSome: vnode => {
+                const actualText = textContent(vnode);
+                return {
+                    pass: actualText === expected,
+                    message: () => 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    this.isNot
+                        ? `Expected element not to have text "${expected}" but it does.`
+                        : `Expected element to have text "${expected}" but received "${actualText}".`,
+                };
+            },
+        });
+    },
+    toContainText(received, expected) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => `Expected element to contain text "${expected}" but the element does not exist.`,
+            }),
+            onSome: vnode => {
+                const actualText = textContent(vnode);
+                return {
+                    pass: actualText.includes(expected),
+                    message: () => 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    this.isNot
+                        ? `Expected element not to contain text "${expected}" but it does.`
+                        : `Expected element to contain text "${expected}" but received "${actualText}".`,
+                };
+            },
+        });
+    },
+    toHaveClass(received, expected) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => `Expected element to have class "${expected}" but the element does not exist.`,
+            }),
+            onSome: vnode => ({
+                pass: vnode.data?.class?.[expected] === true,
+                message: () => 
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                this.isNot
+                    ? `Expected element not to have class "${expected}" but it does.`
+                    : `Expected element to have class "${expected}" but it does not.`,
+            }),
+        });
+    },
+    toHaveAttr(received, name, expectedValue) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => expectedValue === undefined
+                    ? `Expected element to have attribute "${name}" but the element does not exist.`
+                    : `Expected element to have attribute ${name}="${expectedValue}" but the element does not exist.`,
+            }),
+            onSome: vnode => {
+                const actualValue = attr(vnode, name);
+                if (expectedValue === undefined) {
+                    return {
+                        pass: Option.isSome(actualValue),
+                        message: () => 
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        this.isNot
+                            ? `Expected element not to have attribute "${name}" but it does.`
+                            : `Expected element to have attribute "${name}" but it is not present.`,
+                    };
+                }
+                return Option.match(actualValue, {
+                    onNone: () => ({
+                        pass: false,
+                        message: () => `Expected element to have attribute ${name}="${expectedValue}" but the attribute is not present.`,
+                    }),
+                    onSome: actual => ({
+                        pass: actual === expectedValue,
+                        message: () => 
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        this.isNot
+                            ? `Expected element not to have attribute ${name}="${expectedValue}" but it does.`
+                            : `Expected element to have attribute ${name}="${expectedValue}" but received "${actual}".`,
+                    }),
+                });
+            },
+        });
+    },
+    toExist(received) {
+        return {
+            pass: Option.isSome(received),
+            message: () => 
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            this.isNot
+                ? 'Expected element not to exist but it does.'
+                : 'Expected element to exist but it does not.',
+        };
+    },
+    toBeAbsent(received) {
+        return {
+            pass: Option.isNone(received),
+            message: () => 
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            this.isNot
+                ? 'Expected element not to be absent but it is.'
+                : 'Expected element to be absent but it exists.',
+        };
+    },
+    toHaveStyle(received, name, expectedValue) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => expectedValue === undefined
+                    ? `Expected element to have style "${name}" but the element does not exist.`
+                    : `Expected element to have style ${name}="${expectedValue}" but the element does not exist.`,
+            }),
+            onSome: vnode => {
+                const maybeActualValue = Option.fromNullable(vnode.data?.style?.[name]);
+                if (expectedValue === undefined) {
+                    return {
+                        pass: Option.isSome(maybeActualValue),
+                        message: () => 
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        this.isNot
+                            ? `Expected element not to have style "${name}" but it does.`
+                            : `Expected element to have style "${name}" but it is not present.`,
+                    };
+                }
+                return Option.match(maybeActualValue, {
+                    onNone: () => ({
+                        pass: false,
+                        message: () => `Expected element to have style ${name}="${expectedValue}" but the style is not present.`,
+                    }),
+                    onSome: actualValue => {
+                        const actual = String(actualValue);
+                        return {
+                            pass: actual === expectedValue,
+                            message: () => 
+                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                            this.isNot
+                                ? `Expected element not to have style ${name}="${expectedValue}" but it does.`
+                                : `Expected element to have style ${name}="${expectedValue}" but received "${actual}".`,
+                        };
+                    },
+                });
+            },
+        });
+    },
+    toHaveHook(received, name) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => `Expected element to have hook "${name}" but the element does not exist.`,
+            }),
+            onSome: vnode => {
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                const hooks = vnode.data?.hook;
+                return {
+                    pass: typeof hooks?.[name] === 'function',
+                    message: () => 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    this.isNot
+                        ? `Expected element not to have hook "${name}" but it does.`
+                        : `Expected element to have hook "${name}" but it is not present.`,
+                };
+            },
+        });
+    },
+    toHaveHandler(received, name) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => `Expected element to have handler "${name}" but the element does not exist.`,
+            }),
+            onSome: vnode => ({
+                pass: vnode.data?.on?.[name] !== undefined,
+                message: () => 
+                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                this.isNot
+                    ? `Expected element not to have handler "${name}" but it does.`
+                    : `Expected element to have handler "${name}" but it is not present.`,
+            }),
+        });
+    },
+    toHaveValue(received, expected) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => `Expected element to have value "${expected}" but the element does not exist.`,
+            }),
+            onSome: vnode => {
+                const actualValue = attr(vnode, 'value');
+                return Option.match(actualValue, {
+                    onNone: () => ({
+                        pass: false,
+                        message: () => `Expected element to have value "${expected}" but the element has no value.`,
+                    }),
+                    onSome: actual => ({
+                        pass: actual === expected,
+                        message: () => 
+                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                        this.isNot
+                            ? `Expected element not to have value "${expected}" but it does.`
+                            : `Expected element to have value "${expected}" but received "${actual}".`,
+                    }),
+                });
+            },
+        });
+    },
+    toBeDisabled(received) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => 'Expected element to be disabled but the element does not exist.',
+            }),
+            onSome: vnode => {
+                const disabled = attr(vnode, 'disabled');
+                const ariaDisabled = attr(vnode, 'aria-disabled');
+                const pass = (Option.isSome(disabled) && disabled.value !== 'false') ||
+                    (Option.isSome(ariaDisabled) && ariaDisabled.value === 'true');
+                return {
+                    pass,
+                    message: () => 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    this.isNot
+                        ? 'Expected element not to be disabled but it is.'
+                        : 'Expected element to be disabled but it is not.',
+                };
+            },
+        });
+    },
+    toBeEnabled(received) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => 'Expected element to be enabled but the element does not exist.',
+            }),
+            onSome: vnode => {
+                const disabled = attr(vnode, 'disabled');
+                const ariaDisabled = attr(vnode, 'aria-disabled');
+                const isDisabled = (Option.isSome(disabled) && disabled.value !== 'false') ||
+                    (Option.isSome(ariaDisabled) && ariaDisabled.value === 'true');
+                return {
+                    pass: !isDisabled,
+                    message: () => 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    this.isNot
+                        ? 'Expected element not to be enabled but it is.'
+                        : 'Expected element to be enabled but it is disabled.',
+                };
+            },
+        });
+    },
+    toBeChecked(received) {
+        return Option.match(received, {
+            onNone: () => ({
+                pass: false,
+                message: () => 'Expected element to be checked but the element does not exist.',
+            }),
+            onSome: vnode => {
+                const checked = attr(vnode, 'checked');
+                const ariaChecked = attr(vnode, 'aria-checked');
+                const pass = (Option.isSome(checked) && checked.value !== 'false') ||
+                    (Option.isSome(ariaChecked) && ariaChecked.value === 'true');
+                return {
+                    pass,
+                    message: () => 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    this.isNot
+                        ? 'Expected element not to be checked but it is.'
+                        : 'Expected element to be checked but it is not.',
+                };
+            },
+        });
+    },
+};

package/dist/test/public.d.ts

@@ -1,3 +1,3 @@
-export type { AnyCommand, ResolverPair, Simulation, StoryStep, WithStep, } from './index';
-export { message, resolve, resolveAll, story, tap, with } from './index';
+export * as Story from './story';
+export * as Scene from './scene';
 //# sourceMappingURL=public.d.ts.map

package/dist/test/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/test/public.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,SAAS,EACT,QAAQ,GACT,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/test/public.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA"}

package/dist/test/public.js

@@ -1 +1,2 @@
-export { message, resolve, resolveAll, story, tap, with } from './index';
+export * as Story from './story';
+export * as Scene from './scene';