@mauroandre/velojs 0.0.60 → 0.0.61

package/dist/testing/subscription.d.ts

@@ -19,6 +19,13 @@ interface BuildSubscriptionOptions {
      * "slice", data }`. `next()` keeps the slice-1 contract: the raw `data`.
      */
     channelEvents?: boolean;
+    /**
+     * Live-action mode: a server-reported `error` event (the source failed) is
+     * recorded discriminated in `nextEvent()` as `{ type: "error", data }` and
+     * does NOT enter `events`/`next()` — an error is not a payload. Snapshots
+     * keep the `channelEvents` behavior.
+     */
+    liveEvents?: boolean;
 }
 export declare function buildSubscription<TEvent, TSnapshot>(opts: BuildSubscriptionOptions): Promise<TestSubscription<TEvent, TSnapshot> & {
     /** Next arrival discriminated by the mode that delivered it. */

package/dist/testing/types.d.ts

@@ -107,6 +107,17 @@ export interface ChannelSubscribeOptions extends SubscribeOptions {
     /** Route params the connection declares (serialized into `?_route=`). */
     params?: Params;
 }
+/**
+ * Options of a live action subscription.
+ *
+ * `args` are the arguments the subscription declares — the same ones the hook
+ * serializes into `?_args=`. They are the subscription's identity and the
+ * `body` of every (re-)execution; the size guard and the scope run for real.
+ */
+export interface LiveActionSubscribeOptions extends SubscribeOptions {
+    /** The action's declared args (serialized into `?_args=`). */
+    args?: Record<string, unknown>;
+}
 export interface NextOptions {
     /** Reject if no event arrives within this many ms. */
     timeoutMs: number;
@@ -169,9 +180,13 @@ export interface TestChannelSubscription<T = any> extends TestSubscription<T, T>
     /** Next arrival, discriminated by the mode that delivered it. */
     nextEvent(opts: NextOptions): Promise<ChannelEvent<T>>;
 }
-/** One channel arrival: a whole snapshot or a slice to be merged. */
+/**
+ * One channel arrival: a whole snapshot, a slice to be merged, or a reported
+ * failure of the source (a live action subscription receives `{ message }` —
+ * its last valid value stays in place on the client).
+ */
 export interface ChannelEvent<T = any> {
-    type: "snapshot" | "slice";
+    type: "snapshot" | "slice" | "error";
     data: T;
 }
 /** The module (or moduleId) a channel belongs to, as `app.channel()` accepts it. */
@@ -253,6 +268,32 @@ export interface TestApp {
      * ```
      */
     channel<T = any>(module: ChannelModuleRef, name: string, opts?: ChannelSubscribeOptions): Promise<TestChannelSubscription<T>>;
+    /**
+     * Open a live action subscription — the server-side twin of
+     * `useLiveAction(action, args)`.
+     *
+     * The module may be the imported route module (its `metadata.moduleId` is
+     * read) or a moduleId string; `name` is the action name WITHOUT the
+     * `action_` prefix. Cookies (and therefore the principal) come from the
+     * options or from `app.as(user)`; the route node's middlewares run for
+     * real, so an unauthenticated subscription is denied exactly as in
+     * production. `opts.args` are the declared arguments — serialized into
+     * `?_args=`, validated by the size guard and consumed by the scope.
+     *
+     * `next()` delivers the payloads in arrival order (the connect snapshot
+     * first — it is the loading gesture); `nextEvent()` discriminates the
+     * arrival (`{ type: "snapshot" | "error", data }`); `close()` ends the
+     * subscription.
+     *
+     * ```ts
+     * const sub = await app.as({ id: 1 }).liveAction(Project, "abrirFicha", { args: { id: 7 } });
+     * expect(await sub.next({ timeoutMs: 1000 })).toEqual({ nome: "Site" });  // connect
+     *
+     * await emit("fichaProjeto", { args: { id: 7 } });
+     * expect(await sub.next({ timeoutMs: 1000 })).toEqual({ nome: "Site", fase: "review" });
+     * ```
+     */
+    liveAction<T = any>(module: ChannelModuleRef, name: string, opts?: LiveActionSubscribeOptions): Promise<TestChannelSubscription<T>>;
     /**
      * Open an in-memory session against a `socket_*` handler.
      *

package/dist/types.d.ts

@@ -29,6 +29,18 @@ export interface RouteModule {
      * dev/build error. Requires an entry per name in `app/channels.ts`.
      */
     channels?: readonly string[];
+    /**
+     * Live actions — the tab-facing twin of `channels`. The key is the action
+     * name WITHOUT the `action_` prefix (the same form as the
+     * `/_action/{moduleId}/{name}` path); the value is the list of channel
+     * names — a `useLiveAction(action, args)` subscription enters the groups
+     * of all of them, so an `emit` in any one re-executes the action with the
+     * subscription's own args and pushes the fresh value. Requires the action
+     * to exist in the module and an entry per channel in `app/channels.ts`.
+     * A live action is, by contract, a parameterized read: re-executing it
+     * must be side-effect free.
+     */
+    liveActions?: Readonly<Record<string, readonly string[]>>;
     staticPaths?: () => Promise<Record<string, string>[]>;
     metadata?: Metadata;
     [key: `action_${string}`]: (args: ActionArgs<any>) => Promise<any>;

package/dist/vite.d.ts

@@ -3,7 +3,7 @@ import type { VeloConfig } from "./config.js";
 import * as t from "@babel/types";
 export declare function injectMetadata(code: string, moduleId: string, fullPath?: string, path?: string): string;
 export declare function transformLoaderFunctions(code: string, moduleId: string): string;
-export declare function transformActionsForClient(code: string, moduleId: string): string;
+export declare function transformActionsForClient(code: string, moduleId: string, liveNames?: ReadonlySet<string> | undefined): string;
 /**
  * Transforma `export const stream_xxx = createEventStream({...})` no client em
  * um stub com apenas { __isVeloEventStream: true, __path: "/_event/{moduleId}/{name}" }.
@@ -81,6 +81,16 @@ export declare function declaredChannelNames(code: string): string[] | null;
  * A missing file yields an empty set, which makes every declaration unknown.
  */
 export declare function readChannelMapNames(file: string): Set<string>;
+/**
+ * Actions declared live by a module's `liveActions` export — `null` when the
+ * module does not declare the convention.
+ *
+ * The canonical form is the object literal `{ actionName: [channel, …] }` (the
+ * key WITHOUT the `action_` prefix, the value an array of channel-name
+ * literals); anything else is left alone — the registration guard on the
+ * server side is the backstop for runtime-computed declarations.
+ */
+export declare function declaredLiveActions(code: string): Record<string, string[]> | null;
 export interface ModuleTransformOptions {
     /** Absolute module id (the Vite module id). */
     id: string;