foldkit 0.45.0 → 0.46.1

package/dist/test/scene.js

@@ -1,14 +1,51 @@
-import { Array, Effect, Function, Option, Predicate, pipe } from 'effect';
+import { Array, Effect, Function, Option, Predicate, String as String_, pipe, } from 'effect';
 import { dual } from 'effect/Function';
 import { Dispatch } from '../runtime';
 import { assertAllCommandsResolved, assertNoUnresolvedCommands, resolveByName, } from './internal';
-import { attr, resolveTarget, textContent } from './query';
-export { find, findAll, textContent, attr, getByRole, getAllByRole, getByText, getByPlaceholder, getByLabel, role, placeholder, label, selector, text, within, } from './query';
+import { accessibleDescription, accessibleName, ancestorsOf, attr, resolveTarget, selector, textContent, within, } from './query';
+import { allAltText, allDisplayValue, allLabel, allPlaceholder, allRole, allSelector, allTestId, allText, allTitle, } from './query';
+export { find, findAll, textContent, attr, getByRole, getAllByRole, getByText, getByPlaceholder, getByLabel, getByAltText, getByTitle, getByTestId, getByDisplayValue, role, placeholder, label, altText, title, testId, displayValue, selector, text, within, getAllByText, getAllByLabel, getAllByPlaceholder, getAllByAltText, getAllByTitle, getAllByTestId, getAllByDisplayValue, first, last, nth, filter, } from './query';
+/** Multi-match Locator factories. Each returns a `LocatorAll` that resolves
+ *  to every matching VNode. Convert to a single `Locator` via `first`,
+ *  `last`, or `nth(n)`, or narrow via `filter`. */
+export const all = {
+    role: allRole,
+    text: allText,
+    label: allLabel,
+    placeholder: allPlaceholder,
+    altText: allAltText,
+    title: allTitle,
+    testId: allTestId,
+    displayValue: allDisplayValue,
+    selector: allSelector,
+};
 export { sceneMatchers } from './matchers';
 const UNINITIALIZED = Symbol('uninitialized');
 const toInternal = (simulation) => 
 // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 simulation;
+const applyScopeToTarget = (scope, target) => Option.match(scope, {
+    onNone: () => target,
+    onSome: parent => typeof target === 'string'
+        ? within(parent, selector(target))
+        : within(parent, target),
+});
+const applyScopeToLocator = (scope, locator) => Option.match(scope, {
+    onNone: () => locator,
+    onSome: parent => within(parent, locator),
+});
+const applyScopeToLocatorAll = (scope, locatorAll) => Option.match(scope, {
+    onNone: () => locatorAll,
+    onSome: parent => {
+        const resolve = (html) => Option.match(parent(html), {
+            onNone: () => [],
+            onSome: locatorAll,
+        });
+        return Object.assign(resolve, {
+            description: `${locatorAll.description} within ${parent.description}`,
+        });
+    },
+});
 // CAPTURING DISPATCH
 const createCapturingDispatch = () => {
     let capturedMessage;
@@ -38,18 +75,18 @@ const renderView = (viewFn, model, dispatch) => {
 // INTERACTION HELPERS
 const EVENT_NAMES = {
     click: 'OnClick',
+    dblclick: 'OnDblClick',
     submit: 'OnSubmit',
     input: 'OnInput',
+    change: 'OnChange',
+    focus: 'OnFocus',
+    blur: 'OnBlur',
+    mouseenter: 'OnMouseEnter',
+    mouseover: 'OnMouseOver',
     keydown: 'OnKeyDown or OnKeyDownPreventDefault',
 };
-const invokeAndCapture = (simulation, target, eventName, invokeHandler) => {
+const captureFromElement = (simulation, element, description, eventName, invokeHandler) => {
     const internal = toInternal(simulation);
-    const { maybeElement, description } = resolveTarget(internal.html, target);
-    if (Option.isNone(maybeElement)) {
-        throw new Error(`I could not find an element matching ${description}.\n\n` +
-            'Check that your selector matches an element in the current view.');
-    }
-    const element = maybeElement.value;
     const maybeHandler = Option.fromNullable(element.data?.on?.[eventName]);
     if (Option.isNone(maybeHandler)) {
         const attributeName = EVENT_NAMES[eventName] ?? eventName;
@@ -78,6 +115,46 @@ const invokeAndCapture = (simulation, target, eventName, invokeHandler) => {
     };
     /* eslint-enable @typescript-eslint/consistent-type-assertions */
 };
+const invokeAndCapture = (simulation, target, eventName, invokeHandler) => {
+    const internal = toInternal(simulation);
+    const scopedTarget = applyScopeToTarget(internal.scope, target);
+    const { maybeElement, description } = resolveTarget(internal.html, scopedTarget);
+    if (Option.isNone(maybeElement)) {
+        throw new Error(`I could not find an element matching ${description}.\n\n` +
+            'Check that your selector matches an element in the current view.');
+    }
+    return captureFromElement(simulation, maybeElement.value, description, eventName, invokeHandler);
+};
+const lookupTypeAttribute = (vnode) => {
+    const fromAttrs = vnode.data?.attrs?.['type'];
+    const fromProps = vnode.data?.props?.['type'];
+    return typeof fromAttrs === 'string'
+        ? fromAttrs
+        : typeof fromProps === 'string'
+            ? fromProps
+            : undefined;
+};
+const isSubmitButton = (element) => {
+    const type = lookupTypeAttribute(element);
+    if (element.sel === 'button') {
+        return type === undefined || type === 'submit';
+    }
+    if (element.sel === 'input') {
+        return type === 'submit' || type === 'image';
+    }
+    return false;
+};
+const isElementDisabled = (element) => {
+    const attrDisabled = element.data?.attrs?.['disabled'];
+    const propDisabled = element.data?.props?.['disabled'];
+    const ariaDisabled = element.data?.attrs?.['aria-disabled'];
+    return (attrDisabled === true ||
+        attrDisabled === '' ||
+        attrDisabled === 'disabled' ||
+        propDisabled === true ||
+        ariaDisabled === 'true' ||
+        ariaDisabled === true);
+};
 const DEFAULT_KEYBOARD_MODIFIERS = {
     shiftKey: false,
     ctrlKey: false,
@@ -155,11 +232,109 @@ export const tap = (f) => (simulation) => {
     f(simulation);
     return simulation;
 };
+const runSteps = (seed, steps) => 
+/* eslint-disable @typescript-eslint/consistent-type-assertions */
+Array.reduce(steps, seed, (current, step) => {
+    const next = step(current);
+    const internal = toInternal(next);
+    if (internal.model !== UNINITIALIZED) {
+        const html = renderView(internal.viewFn, internal.model, internal.capturingDispatch.dispatch);
+        return { ...internal, html };
+    }
+    return next;
+});
+/* eslint-enable @typescript-eslint/consistent-type-assertions */
+/** Scopes a sequence of steps to a parent element. Every Locator referenced by
+ *  child steps — assertions, interactions — resolves within the parent's subtree.
+ *  Use this when several steps share the same scope. For a single scoped query,
+ *  prefer `within(parent, child)` directly. Nested `inside` calls compose scopes
+ *  via `within(outer, inner)`. */
+export const inside = (parent, ...steps) => (simulation) => {
+    const internal = toInternal(simulation);
+    const priorScope = internal.scope;
+    const nextScope = Option.match(priorScope, {
+        onNone: () => parent,
+        onSome: within(parent),
+    });
+    /* eslint-disable @typescript-eslint/consistent-type-assertions */
+    const scopedEntry = {
+        ...internal,
+        scope: Option.some(nextScope),
+    };
+    const afterSteps = runSteps(scopedEntry, steps);
+    const afterInternal = toInternal(afterSteps);
+    return {
+        ...afterInternal,
+        scope: priorScope,
+    };
+    /* eslint-enable @typescript-eslint/consistent-type-assertions */
+};
 // INTERACTION STEPS
-/** Simulates a click on the element matching the target. */
-export const click = (target) => (simulation) => invokeAndCapture(simulation, target, 'click', handler => {
+/** Simulates a click on the element matching the target.
+ *  When the element is a submit button (`<button>` with no type or
+ *  `type="submit"`, `<input type="submit">`, `<input type="image">`) with no
+ *  click handler of its own, the click falls through to the `submit` handler
+ *  of the nearest ancestor `<form>` — mirroring browser behavior. */
+export const click = (target) => (simulation) => {
+    const internal = toInternal(simulation);
+    const scopedTarget = applyScopeToTarget(internal.scope, target);
+    const { maybeElement, description } = resolveTarget(internal.html, scopedTarget);
+    if (Option.isNone(maybeElement)) {
+        throw new Error(`I could not find an element matching ${description}.\n\n` +
+            'Check that your selector matches an element in the current view.');
+    }
+    const element = maybeElement.value;
+    if (isElementDisabled(element)) {
+        throw new Error(`I found an element matching ${description} but it is disabled.\n\n` +
+            'Disabled elements do not receive click events in the browser. ' +
+            'Assert the state that enables the element before clicking, or ' +
+            'use Scene.expect(locator).not.toBeDisabled() to verify the ' +
+            'element is interactive.');
+    }
+    const hasClickHandler = element.data?.on?.['click'] !== undefined;
+    if (!hasClickHandler && isSubmitButton(element)) {
+        const maybeForm = pipe(ancestorsOf(internal.html, element), Array.findLast(vnode => vnode.sel === 'form'));
+        if (Option.isSome(maybeForm)) {
+            return captureFromElement(simulation, maybeForm.value, `form containing ${description}`, 'submit', handler => {
+                handler({ preventDefault: Function.constVoid });
+            });
+        }
+    }
+    return captureFromElement(simulation, element, description, 'click', handler => {
+        handler();
+    });
+};
+/** Simulates a double-click on the element matching the target. */
+export const doubleClick = (target) => (simulation) => invokeAndCapture(simulation, target, 'dblclick', handler => {
+    handler();
+});
+/** Simulates a hover (mouseenter) on the element matching the target.
+ *  Dispatches the `mouseenter` handler, falling back to `mouseover`. */
+export const hover = (target) => (simulation) => {
+    const internal = toInternal(simulation);
+    const scopedTarget = applyScopeToTarget(internal.scope, target);
+    const { maybeElement } = resolveTarget(internal.html, scopedTarget);
+    const eventName = Option.match(maybeElement, {
+        onNone: () => 'mouseenter',
+        onSome: element => element.data?.on?.['mouseenter'] ? 'mouseenter' : 'mouseover',
+    });
+    return invokeAndCapture(simulation, target, eventName, handler => {
+        handler();
+    });
+};
+/** Simulates a focus event on the element matching the target. */
+export const focus = (target) => (simulation) => invokeAndCapture(simulation, target, 'focus', handler => {
     handler();
 });
+/** Simulates a blur event on the element matching the target. */
+export const blur = (target) => (simulation) => invokeAndCapture(simulation, target, 'blur', handler => {
+    handler();
+});
+/** Simulates a change event on the element matching the target.
+ *  Dual: `change(target, value)` or `change(value)` for data-last piping. */
+export const change = dual(2, (target, value) => (simulation) => invokeAndCapture(simulation, target, 'change', handler => {
+    handler({ target: { value } });
+}));
 /** Simulates form submission on the element matching the target. */
 export const submit = (target) => (simulation) => invokeAndCapture(simulation, target, 'submit', handler => {
     handler({ preventDefault: Function.constVoid });
@@ -182,17 +357,18 @@ export const keydown = dual((args) => args.length >= 2 && typeof args[1] === 'st
 }));
 const wrapAssertion = (locator, assertion, isNot) => (simulation) => {
     const internal = toInternal(simulation);
-    assertion(locator(internal.html), locator.description, isNot);
+    const scopedLocator = applyScopeToLocator(internal.scope, locator);
+    assertion(scopedLocator(internal.html), scopedLocator.description, isNot, internal.html);
     return simulation;
 };
-const assertOnElement = (check, expectation) => (maybeElement, description, isNot) => {
+const assertOnElement = (check, expectation) => (maybeElement, description, isNot, root) => {
     if (Option.isNone(maybeElement)) {
         if (!isNot) {
             throw new Error(`Expected element matching ${description} to ${expectation} but the element does not exist.`);
         }
         return;
     }
-    const { pass, actual } = check(maybeElement.value);
+    const { pass, actual } = check(maybeElement.value, root);
     if (isNot ? pass : !pass) {
         throw new Error(isNot
             ? `Expected element matching ${description} not to ${expectation} but it does.`
@@ -215,14 +391,17 @@ const assertAbsent = (maybeElement, description, isNot) => {
             : `Expected element matching ${description} to be absent but it exists.`);
     }
 };
+const describeExpected = (expected) => expected instanceof RegExp ? `${expected}` : `"${expected}"`;
+const textMatches = (value, expected) => expected instanceof RegExp ? expected.test(value) : value === expected;
+const textIncludes = (value, expected) => expected instanceof RegExp ? expected.test(value) : value.includes(expected);
 const assertHasText = (expected) => assertOnElement(vnode => ({
-    pass: textContent(vnode) === expected,
+    pass: textMatches(textContent(vnode), expected),
     actual: `received "${textContent(vnode)}"`,
-}), `have text "${expected}"`);
+}), `have text ${describeExpected(expected)}`);
 const assertContainsText = (expected) => assertOnElement(vnode => ({
-    pass: textContent(vnode).includes(expected),
+    pass: textIncludes(textContent(vnode), expected),
     actual: `received "${textContent(vnode)}"`,
-}), `contain text "${expected}"`);
+}), `contain text ${describeExpected(expected)}`);
 const assertHasAttr = (name, value) => assertOnElement(vnode => {
     const actualValue = attr(vnode, name);
     if (Predicate.isUndefined(value)) {
@@ -314,6 +493,56 @@ const assertIsChecked = assertOnElement(vnode => {
         (Option.isSome(ariaChecked) && ariaChecked.value === 'true');
     return { pass, actual: 'it is not checked' };
 }, 'be checked');
+const isHidden = (vnode) => {
+    const hiddenAttr = attr(vnode, 'hidden');
+    if (Option.isSome(hiddenAttr) && hiddenAttr.value !== 'false')
+        return true;
+    const ariaHidden = attr(vnode, 'aria-hidden');
+    if (Option.isSome(ariaHidden) && ariaHidden.value === 'true')
+        return true;
+    const display = vnode.data?.style?.['display'];
+    if (display === 'none')
+        return true;
+    const visibility = vnode.data?.style?.['visibility'];
+    if (visibility === 'hidden')
+        return true;
+    return false;
+};
+const assertIsVisible = assertOnElement(vnode => ({ pass: !isHidden(vnode), actual: 'it is hidden' }), 'be visible');
+const assertHasAccessibleName = (expected) => assertOnElement((vnode, root) => {
+    const actual = accessibleName(root)(vnode);
+    return {
+        pass: textMatches(actual, expected),
+        actual: `received "${actual}"`,
+    };
+}, `have accessible name ${describeExpected(expected)}`);
+const assertHasAccessibleDescription = (expected) => assertOnElement((vnode, root) => {
+    const actual = accessibleDescription(root)(vnode);
+    return {
+        pass: textMatches(actual, expected),
+        actual: `received "${actual}"`,
+    };
+}, `have accessible description ${describeExpected(expected)}`);
+const assertIsEmpty = assertOnElement(vnode => {
+    const childCount = (vnode.children ?? []).length;
+    const text = textContent(vnode);
+    return {
+        pass: String_.isEmpty(text) && childCount === 0,
+        actual: String_.isNonEmpty(text)
+            ? `received text "${text}"`
+            : `received ${childCount} child(ren)`,
+    };
+}, 'be empty');
+const assertHasId = (expected) => assertOnElement(vnode => {
+    const actualId = attr(vnode, 'id');
+    return Option.match(actualId, {
+        onNone: () => ({ pass: false, actual: 'the element has no id' }),
+        onSome: actual => ({
+            pass: actual === expected,
+            actual: `received "${actual}"`,
+        }),
+    });
+}, `have id "${expected}"`);
 const buildExpectChain = (locator, isNot) => ({
     toExist: () => wrapAssertion(locator, assertExists, isNot),
     toBeAbsent: () => wrapAssertion(locator, assertAbsent, isNot),
@@ -327,6 +556,11 @@ const buildExpectChain = (locator, isNot) => ({
     toHaveValue: (expected) => wrapAssertion(locator, assertHasValue(expected), isNot),
     toBeDisabled: () => wrapAssertion(locator, assertIsDisabled, isNot),
     toBeEnabled: () => wrapAssertion(locator, assertIsEnabled, isNot),
+    toBeEmpty: () => wrapAssertion(locator, assertIsEmpty, isNot),
+    toBeVisible: () => wrapAssertion(locator, assertIsVisible, isNot),
+    toHaveId: (expected) => wrapAssertion(locator, assertHasId(expected), isNot),
+    toHaveAccessibleName: (expected) => wrapAssertion(locator, assertHasAccessibleName(expected), isNot),
+    toHaveAccessibleDescription: (expected) => wrapAssertion(locator, assertHasAccessibleDescription(expected), isNot),
     toBeChecked: () => wrapAssertion(locator, assertIsChecked, isNot),
 });
 /** Creates an inline assertion step. Resolves the Locator against
@@ -336,6 +570,32 @@ const expect_ = (locator) => ({
     ...buildExpectChain(locator, false),
     not: buildExpectChain(locator, true),
 });
+// LOCATOR-ALL ASSERTIONS
+const wrapAllAssertion = (locatorAll, assertion, isNot) => (simulation) => {
+    const internal = toInternal(simulation);
+    const scopedLocatorAll = applyScopeToLocatorAll(internal.scope, locatorAll);
+    assertion(scopedLocatorAll(internal.html), scopedLocatorAll.description, isNot);
+    return simulation;
+};
+const assertCount = (expected) => (matches, description, isNot) => {
+    const actual = matches.length;
+    const pass = actual === expected;
+    if (isNot ? pass : !pass) {
+        throw new Error(isNot
+            ? `Expected elements matching ${description} not to have count ${expected} but they do.`
+            : `Expected elements matching ${description} to have count ${expected} but received ${actual}.`);
+    }
+};
+const buildExpectAllChain = (locatorAll, isNot) => ({
+    toHaveCount: (expected) => wrapAllAssertion(locatorAll, assertCount(expected), isNot),
+    toBeEmpty: () => wrapAllAssertion(locatorAll, assertCount(0), isNot),
+});
+/** Creates an inline multi-match assertion step. Use for count-based
+ *  assertions like `toHaveCount(n)` or `toBeEmpty()`. */
+export const expectAll = (locatorAll) => ({
+    ...buildExpectAllChain(locatorAll, false),
+    not: buildExpectAllChain(locatorAll, true),
+});
 // SUBMODEL VIEW ADAPTER
 /** Adapts a submodel view for Scene testing. In the Submodel pattern, the view
  *  takes a `toParentMessage` function that maps child Messages to parent Messages.
@@ -357,16 +617,9 @@ export const scene = (config, ...steps) => {
         html: undefined,
         viewFn: config.view,
         capturingDispatch,
+        scope: Option.none(),
     };
-    const result = steps.reduce((current, step) => {
-        const next = step(current);
-        const internal = toInternal(next);
-        if (internal.model !== UNINITIALIZED) {
-            const html = renderView(internal.viewFn, internal.model, internal.capturingDispatch.dispatch);
-            return { ...internal, html };
-        }
-        return next;
-    }, seed);
+    const result = runSteps(seed, steps);
     /* eslint-enable @typescript-eslint/consistent-type-assertions */
     const internal = toInternal(result);
     assertAllCommandsResolved(internal.commands);

package/dist/test/vitest-setup.d.ts

@@ -1,19 +1,2 @@
-declare module 'vitest' {
-    interface Assertion<T> {
-        toHaveText(expected: string): this;
-        toContainText(expected: string): this;
-        toHaveClass(expected: string): this;
-        toHaveAttr(name: string, value?: string): this;
-        toHaveStyle(name: string, value?: string): this;
-        toHaveHook(name: string): this;
-        toHaveHandler(name: string): this;
-        toHaveValue(expected: string): this;
-        toBeDisabled(): this;
-        toBeEnabled(): this;
-        toBeChecked(): this;
-        toExist(): this;
-        toBeAbsent(): this;
-    }
-}
 export {};
 //# sourceMappingURL=vitest-setup.d.ts.map

package/dist/test/vitest-setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vitest-setup.d.ts","sourceRoot":"","sources":["../../src/test/vitest-setup.ts"],"names":[],"mappings":"AAIA,OAAO,QAAQ,QAAQ,CAAC;IAEtB,UAAU,SAAS,CAAC,CAAC;QACnB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QAClC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QACrC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QACnC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAC9C,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAC/C,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;QAC9B,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;QACjC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QACnC,YAAY,IAAI,IAAI,CAAA;QACpB,WAAW,IAAI,IAAI,CAAA;QACnB,WAAW,IAAI,IAAI,CAAA;QACnB,OAAO,IAAI,IAAI,CAAA;QACf,UAAU,IAAI,IAAI,CAAA;KACnB;CACF"}
+{"version":3,"file":"vitest-setup.d.ts","sourceRoot":"","sources":["../../src/test/vitest-setup.ts"],"names":[],"mappings":""}

package/dist/test/vitest-setup.js

@@ -1,3 +1,2 @@
-import { expect } from 'vitest';
-import { sceneMatchers } from './matchers';
-expect.extend(sceneMatchers);
+import { setup } from './vitest';
+setup();

package/dist/test/vitest.d.ts

@@ -0,0 +1,33 @@
+declare module 'vitest' {
+    interface Assertion<T> {
+        toHaveText(expected: string | RegExp): this;
+        toContainText(expected: string | RegExp): this;
+        toHaveClass(expected: string): this;
+        toHaveAttr(name: string, value?: string): this;
+        toHaveStyle(name: string, value?: string): this;
+        toHaveHook(name: string): this;
+        toHaveHandler(name: string): this;
+        toHaveValue(expected: string): this;
+        toBeDisabled(): this;
+        toBeEnabled(): this;
+        toBeChecked(): this;
+        toBeEmpty(): this;
+        toBeVisible(): this;
+        toHaveId(expected: string): this;
+        toExist(): this;
+        toBeAbsent(): this;
+    }
+}
+/** Registers Foldkit's Scene matchers with Vitest's `expect`.
+ *  Call once from your Vitest setup file:
+ *
+ *  ```ts
+ *  // vitest-setup.ts
+ *  import { setup } from 'foldkit/test/vitest'
+ *  setup()
+ *  ```
+ *
+ *  Importing this module also augments `Assertion<T>` with the Scene
+ *  matcher types — no manual `declare module 'vitest'` block needed. */
+export declare const setup: () => void;
+//# sourceMappingURL=vitest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.d.ts","sourceRoot":"","sources":["../../src/test/vitest.ts"],"names":[],"mappings":"AAIA,OAAO,QAAQ,QAAQ,CAAC;IAEtB,UAAU,SAAS,CAAC,CAAC;QACnB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;QAC3C,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;QAC9C,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QACnC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAC9C,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;QAC/C,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;QAC9B,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;QACjC,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QACnC,YAAY,IAAI,IAAI,CAAA;QACpB,WAAW,IAAI,IAAI,CAAA;QACnB,WAAW,IAAI,IAAI,CAAA;QACnB,SAAS,IAAI,IAAI,CAAA;QACjB,WAAW,IAAI,IAAI,CAAA;QACnB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;QAChC,OAAO,IAAI,IAAI,CAAA;QACf,UAAU,IAAI,IAAI,CAAA;KACnB;CACF;AAED;;;;;;;;;;wEAUwE;AACxE,eAAO,MAAM,KAAK,QAAO,IAExB,CAAA"}

package/dist/test/vitest.js

@@ -0,0 +1,16 @@
+import { expect } from 'vitest';
+import { sceneMatchers } from './matchers';
+/** Registers Foldkit's Scene matchers with Vitest's `expect`.
+ *  Call once from your Vitest setup file:
+ *
+ *  ```ts
+ *  // vitest-setup.ts
+ *  import { setup } from 'foldkit/test/vitest'
+ *  setup()
+ *  ```
+ *
+ *  Importing this module also augments `Assertion<T>` with the Scene
+ *  matcher types — no manual `declare module 'vitest'` block needed. */
+export const setup = () => {
+    expect.extend(sceneMatchers);
+};

package/dist/vdom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vdom.d.ts","sourceRoot":"","sources":["../src/vdom.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,OAAO,EACR,MAAM,UAAU,CAAA;AAEjB,YAAY,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,CAAA;AAElB,eAAO,MAAM,KAAK,gIAOhB,CAAA"}
+{"version":3,"file":"vdom.d.ts","sourceRoot":"","sources":["../src/vdom.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,OAAO,EACR,MAAM,UAAU,CAAA;AAIjB,YAAY,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,OAAO,EAAE,CAAA;AAElB,eAAO,MAAM,KAAK,gIAOhB,CAAA"}

package/dist/vdom.js

@@ -1,4 +1,5 @@
-import { attributesModule, classModule, datasetModule, eventListenersModule, init, propsModule, styleModule, toVNode, } from 'snabbdom';
+import { attributesModule, classModule, datasetModule, eventListenersModule, init, styleModule, toVNode, } from 'snabbdom';
+import { propsModule } from './propsModule';
 export { toVNode };
 export const patch = init([
     attributesModule,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldkit",
-  "version": "0.45.0",
+  "version": "0.46.1",
   "description": "A frontend framework for TypeScript, built on Effect, using The Elm Architecture",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,6 +63,10 @@
       "types": "./dist/test/public.d.ts",
       "import": "./dist/test/public.js"
     },
+    "./test/vitest": {
+      "types": "./dist/test/vitest.d.ts",
+      "import": "./dist/test/vitest.js"
+    },
     "./ui": {
       "types": "./dist/ui/index.d.ts",
       "import": "./dist/ui/index.js"