@agent-native/core 0.207.1 → 0.207.2-nightly-20261013011333

package/dist/client/action-query-cache.session-test-fixture.d.ts

@@ -0,0 +1,49 @@
+import type { PersistedClient } from "@tanstack/query-persist-client-core";
+import { QueryClient } from "@tanstack/react-query";
+import { type ComponentType, type ReactNode } from "react";
+import type { AuthSessionResponse } from "../server/auth.js";
+import type { ActionQueryCacheStorage } from "./action-query-cache.js";
+export type Gate = ComponentType<{
+    children: ReactNode;
+}>;
+export type SessionUser = AuthSessionResponse;
+export type ProbeRender = {
+    title: string | undefined;
+    status: string;
+    userId: string | undefined;
+    firstRead: boolean;
+};
+export declare const ALICE: SessionUser;
+export declare const BOB: SessionUser;
+export declare function sessionResponse(user: SessionUser): Response;
+export declare function transientSessionFailure(): Response;
+export declare function designsResponse(title: string): Response;
+export declare function memoryStorage(): {
+    records: Map<string, PersistedClient>;
+    storage: ActionQueryCacheStorage;
+};
+export declare function stubFetch(options: {
+    onSession: (request: number) => Promise<Response> | Response;
+    onAction: (request: number) => Promise<Response> | Response;
+}): {
+    calls: {
+        kind: "session" | "action";
+        path: string;
+    }[];
+    sessionCount: () => number;
+    actionCount: () => number;
+};
+export declare function StatusProbe({ onStatus, }: {
+    onStatus: (value: {
+        status: string;
+        userId: string | undefined;
+    }) => void;
+}): null;
+export declare function mountProbe(GateComponent: Gate, queryClient: QueryClient, onRender: (value: ProbeRender) => void, onStatus?: (value: {
+    status: string;
+    userId: string | undefined;
+}) => void): Promise<HTMLDivElement>;
+export declare function settle(ms?: number): Promise<void>;
+export declare function waitUntil(predicate: () => boolean, timeoutMs?: number): Promise<boolean>;
+export declare function unmountAll(): Promise<void>;
+export { QueryClient };

package/dist/client/action-query-cache.session-test-fixture.js

@@ -0,0 +1,151 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { act } from "react";
+import { createRoot } from "react-dom/client";
+import { vi } from "vitest";
+import { useActionQuery } from "./use-action.js";
+import { isSessionFromFirstRead, useSession } from "./use-session.js";
+const roots = [];
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+let restoreLocalStorage;
+function installLocalStorageForTest() {
+    if (restoreLocalStorage)
+        return;
+    const descriptor = Object.getOwnPropertyDescriptor(window, "localStorage");
+    Object.defineProperty(window, "localStorage", {
+        configurable: true,
+        value: {
+            length: 0,
+            setItem: () => { },
+            getItem: () => null,
+            removeItem: () => { },
+            clear: () => { },
+            key: () => null,
+        },
+    });
+    restoreLocalStorage = () => {
+        if (descriptor)
+            Object.defineProperty(window, "localStorage", descriptor);
+        else
+            Reflect.deleteProperty(window, "localStorage");
+        restoreLocalStorage = undefined;
+    };
+}
+export const ALICE = {
+    email: "alice@example.com",
+    userId: "user-alice",
+    orgId: "org-1",
+    testIdentity: false,
+};
+export const BOB = {
+    email: "bob@example.com",
+    userId: "user-bob",
+    orgId: "org-1",
+    testIdentity: false,
+};
+export function sessionResponse(user) {
+    return new Response(JSON.stringify(user), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+export function transientSessionFailure() {
+    return new Response("temporarily unavailable", { status: 503 });
+}
+export function designsResponse(title) {
+    return new Response(JSON.stringify({ designs: [{ title }] }), {
+        status: 200,
+        headers: {
+            "Content-Type": "application/json",
+            "X-Agent-Native-Browser-Persist": "allow",
+        },
+    });
+}
+export function memoryStorage() {
+    const records = new Map();
+    const storage = {
+        get: async (key) => records.get(key),
+        set: async (key, value) => {
+            records.set(key, value);
+        },
+        del: async (key) => {
+            records.delete(key);
+        },
+        keys: async () => [...records.keys()],
+        clear: async () => {
+            records.clear();
+        },
+    };
+    return { records, storage };
+}
+export function stubFetch(options) {
+    let sessionRequests = 0;
+    let actionRequests = 0;
+    const calls = [];
+    vi.stubGlobal("fetch", vi.fn(async (input) => {
+        const raw = typeof input === "object" && "url" in input
+            ? String(input.url)
+            : String(input);
+        const url = new URL(raw, window.location.href);
+        calls.push({ kind: "session", path: url.pathname });
+        if (url.pathname.endsWith("/_agent-native/auth/session")) {
+            sessionRequests += 1;
+            calls[calls.length - 1].kind = "session";
+            return options.onSession(sessionRequests);
+        }
+        if (url.pathname.includes("/_agent-native/actions/")) {
+            actionRequests += 1;
+            calls[calls.length - 1].kind = "action";
+            return options.onAction(actionRequests);
+        }
+        throw new Error(`Unexpected fetch in private probe: ${url.pathname}`);
+    }));
+    return {
+        calls,
+        sessionCount: () => sessionRequests,
+        actionCount: () => actionRequests,
+    };
+}
+function DesignsProbe({ onRender, }) {
+    const { status, session } = useSession();
+    const query = useActionQuery("list-designs");
+    const title = query.data?.designs[0]?.title;
+    onRender({
+        title,
+        status,
+        userId: session?.userId,
+        firstRead: isSessionFromFirstRead(),
+    });
+    return _jsx("span", { "data-result": true, children: title ?? "pending" });
+}
+export function StatusProbe({ onStatus, }) {
+    const { status, session } = useSession();
+    onStatus({ status, userId: session?.userId });
+    return null;
+}
+export async function mountProbe(GateComponent, queryClient, onRender, onStatus) {
+    installLocalStorageForTest();
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    const root = createRoot(container);
+    roots.push({ root, container });
+    await act(async () => root.render(_jsxs(QueryClientProvider, { client: queryClient, children: [onStatus ? _jsx(StatusProbe, { onStatus: onStatus }) : null, _jsx(GateComponent, { children: _jsx(DesignsProbe, { onRender: onRender }) })] })));
+    return container;
+}
+export async function settle(ms = 20) {
+    await act(async () => new Promise((resolve) => setTimeout(resolve, ms)));
+}
+export async function waitUntil(predicate, timeoutMs = 4_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (!predicate() && Date.now() < deadline)
+        await settle(20);
+    return predicate();
+}
+export async function unmountAll() {
+    for (const { root, container } of roots.splice(0)) {
+        await act(async () => root.unmount());
+        container.remove();
+    }
+    restoreLocalStorage?.();
+}
+export { QueryClient };

package/dist/client/action-query-cache.test-fixtures.d.ts

@@ -0,0 +1,2 @@
+export declare const TEST_CACHE_EPOCH = "cache-test-epoch";
+export declare function cacheBuster(buster?: string): string;

package/dist/client/action-query-cache.test-fixtures.js

@@ -0,0 +1,56 @@
+import { beforeEach } from "vitest";
+const epochKey = "agent-native.action-query-cache.epoch";
+const values = new Map();
+const localStorageShim = {
+    get length() {
+        return values.size;
+    },
+    key(index) {
+        return [...values.keys()][index] ?? null;
+    },
+    getItem(key) {
+        return values.get(key) ?? null;
+    },
+    setItem(key, value) {
+        values.set(key, value);
+    },
+    removeItem(key) {
+        values.delete(key);
+    },
+    clear() {
+        values.clear();
+    },
+};
+beforeEach(() => {
+    values.clear();
+    values.set(epochKey, TEST_CACHE_EPOCH);
+    const global = globalThis;
+    if (!global.window) {
+        Object.defineProperty(globalThis, "window", {
+            configurable: true,
+            value: { localStorage: localStorageShim },
+        });
+        return;
+    }
+    Object.defineProperty(global.window, "localStorage", {
+        configurable: true,
+        value: localStorageShim,
+    });
+});
+export const TEST_CACHE_EPOCH = "cache-test-epoch";
+const CURRENT_CACHE_BUSTER = "action-query-cache-v1";
+const CACHE_EPOCH_KEY = "agent-native.action-query-cache.epoch";
+function currentTestEpoch() {
+    try {
+        return window.localStorage.getItem(CACHE_EPOCH_KEY) ?? TEST_CACHE_EPOCH;
+    }
+    catch {
+        return TEST_CACHE_EPOCH;
+    }
+}
+export function cacheBuster(buster = CURRENT_CACHE_BUSTER) {
+    if (buster === CURRENT_CACHE_BUSTER) {
+        return `${CURRENT_CACHE_BUSTER}:${currentTestEpoch()}`;
+    }
+    return buster;
+}

package/dist/client/motion-text.css

@@ -0,0 +1,3 @@
+.agent-native-motion-text-unit {
+  display: inline-block;
+}

package/dist/client/motion-text.d.ts

@@ -0,0 +1,38 @@
+import { type ReactElement, type ReactNode, type Ref } from "react";
+import "./motion-text.css";
+export type MotionTextUnit = "character" | "word" | "line" | "paragraph";
+export type MotionTextDirection = "forward" | "reverse";
+export type MotionTextProperty = "opacity" | "translate" | "scale" | "rotate" | "filter";
+export type MotionTextPlaybackMode = "loop" | "once" | "ping-pong";
+export interface MotionTextKeyframe {
+    t: number;
+    value: string;
+    ease?: string;
+}
+export interface MotionTextAnimation {
+    targetNodeId: string;
+    unit: MotionTextUnit;
+    direction: MotionTextDirection;
+    staggerMs: number;
+    delayMs?: number;
+    property: MotionTextProperty;
+    durationMs: number;
+    keyframes: MotionTextKeyframe[];
+}
+export interface AgentNativeMotionTextProps {
+    animation?: MotionTextAnimation;
+    animations?: MotionTextAnimation[];
+    playbackMode?: MotionTextPlaybackMode;
+    children: ReactElement;
+}
+type MotionTextHostProps = Record<string, unknown> & {
+    children?: ReactNode;
+    ref?: Ref<HTMLElement>;
+};
+/**
+ * Applies static text property animations to a single intrinsic JSX host element.
+ * Importing this entry includes the package stylesheet; the same asset is
+ * available as `@agent-native/core/client/motion-text.css` for CSS-only setups.
+ */
+export declare function AgentNativeMotionText({ animation, animations: animationList, playbackMode, children, }: AgentNativeMotionTextProps): ReactElement<MotionTextHostProps, string | import("react").JSXElementConstructor<any>>;
+export {};