@orieljs/framework 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/{jsx-runtime-CBZQYYDS.d.ts → jsx-runtime-6um4Mwfb.d.ts}

@@ -1,5 +1,5 @@
 import { Htmlable, OrielError, ErrorKind, View as View$1, ViewFactory } from './contracts.js';
-import { F as Facade, S as ServiceProvider } from './index.d-BJyJx6U1.js';
+import { F as Facade, S as ServiceProvider } from './index.d-WQpfdIbG.js';
 
 /** Marks the objects jsx() returns (Symbol.for, so two copies of the package agree). */
 declare const ELEMENT: unique symbol;
@@ -52,6 +52,93 @@ declare function renderToString(node: Renderable): Promise<string>;
 /** Renders to a UTF-8 byte stream, sending everything rendered so far each time rendering waits on a promise. */
 declare function renderToStream(node: Renderable): ReadableStream<Uint8Array>;
 
+/**
+ * The `o:` attributes of Live components, typed for TSX: a directive (`o:model`, `o:loading`, …) or an action on a DOM
+ * event (`o:click="save"`), with modifiers joined by `-` (`o:model-live`, `o:keydown-enter`). An `o:` name that is
+ * neither doesn't compile (`o:clik`, `o:modle`), and the forms listed here are completed by editors and have their
+ * values checked. TypeScript doesn't check JSX attribute names that contain a `-` unless the type lists them, so a
+ * form that isn't listed (a duration such as `o:model-live-debounce-500ms`, an event's modifiers) is accepted as
+ * written, and so is a misspelt one (`o:model-lvie`).
+ */
+type ModelTrigger = 'live' | 'blur' | 'change' | 'lazy';
+type ElementChange = 'remove' | 'class' | 'class-remove' | 'attr';
+/**
+ * The directives that aren't DOM events, by name: the value each takes (`boolean` for one that can be written bare,
+ * `<a o:navigate>`, or from an expression, `o:navigate={external}`: `false` leaves it out) and its modifier forms, the
+ * `-`-joined text after the name (`never` for none). A new directive adds a member here, and its name to the Live
+ * client's reserved directives.
+ */
+interface LiveDirectives {
+    /** o:model="title": binds an input to a public property, sent with the next request unless live, blur, change or lazy. */
+    model: {
+        value: string;
+        modifiers: ModelTrigger | 'number' | 'debounce' | 'live-debounce' | `${ModelTrigger}-number`;
+    };
+    /** o:loading: shown (or changed) while the component's request runs. */
+    loading: {
+        value: boolean | string;
+        modifiers: ElementChange | 'delay' | `delay-${ElementChange}`;
+    };
+    /** o:target="save,title": the actions or properties o:loading waits for. */
+    target: {
+        value: string;
+        modifiers: never;
+    };
+    /** o:poll="refresh": calls the method ($refresh without one) every 2.5 s, or every `o:poll-<n>s`. */
+    poll: {
+        value: boolean | string;
+        modifiers: 'keep-alive' | 'visible';
+    };
+    /** o:navigate on a link: fetches the page and swaps it in; `-hover` prefetches on hover. */
+    navigate: {
+        value: boolean;
+        modifiers: 'hover';
+    };
+    /** o:offline: shown (or changed) while the browser is offline. */
+    offline: {
+        value: boolean | string;
+        modifiers: ElementChange;
+    };
+    /** o:key: keeps an element's identity across re-renders. */
+    key: {
+        value: string | number;
+        modifiers: never;
+    };
+    /** o:confirm="Delete this tag?": asks before the element's action runs; `-prompt` asks for a typed answer. */
+    confirm: {
+        value: boolean | string;
+        modifiers: 'prompt';
+    };
+    /** o:announce on a status region: an action that leaves the same message announces it again. */
+    announce: {
+        value: boolean;
+        modifiers: never;
+    };
+}
+/**
+ * The DOM events `o:<event>` runs an action on. A name with a `-` can't be written in TSX (modifiers are `-`
+ * segments), and `offline` is the o:offline directive, not the event. An event this list doesn't have (a custom
+ * event a component dispatches) is spread: `<div {...{ 'o:saved': 'refresh' }} />`.
+ */
+type LiveEvent = 'click' | 'dblclick' | 'auxclick' | 'contextmenu' | 'mousedown' | 'mouseup' | 'mousemove' | 'mouseover' | 'mouseout' | 'mouseenter' | 'mouseleave' | 'wheel' | 'pointerdown' | 'pointerup' | 'pointermove' | 'pointerover' | 'pointerout' | 'pointerenter' | 'pointerleave' | 'pointercancel' | 'gotpointercapture' | 'lostpointercapture' | 'keydown' | 'keyup' | 'keypress' | 'input' | 'beforeinput' | 'change' | 'submit' | 'reset' | 'invalid' | 'select' | 'formdata' | 'search' | 'focus' | 'blur' | 'focusin' | 'focusout' | 'copy' | 'cut' | 'paste' | 'drag' | 'dragstart' | 'dragend' | 'dragenter' | 'dragleave' | 'dragover' | 'drop' | 'touchstart' | 'touchend' | 'touchmove' | 'touchcancel' | 'compositionstart' | 'compositionupdate' | 'compositionend' | 'play' | 'pause' | 'playing' | 'ended' | 'timeupdate' | 'volumechange' | 'ratechange' | 'durationchange' | 'loadstart' | 'loadeddata' | 'loadedmetadata' | 'canplay' | 'canplaythrough' | 'seeking' | 'seeked' | 'waiting' | 'stalled' | 'suspend' | 'emptied' | 'progress' | 'abort' | 'error' | 'load' | 'animationstart' | 'animationend' | 'animationiteration' | 'animationcancel' | 'transitionstart' | 'transitionend' | 'transitionrun' | 'transitioncancel' | 'scroll' | 'scrollend' | 'resize' | 'toggle' | 'beforetoggle' | 'close' | 'cancel' | 'online' | 'popstate' | 'hashchange' | 'beforeunload' | 'pagehide' | 'pageshow' | 'storage' | 'message' | 'visibilitychange' | 'selectionchange' | 'fullscreenchange' | 'slotchange' | 'cuechange';
+/** `o:model`, `o:model-live`, …: each directive and each of its modifier forms, with the directive's value. */
+type LiveDirectiveAttributes = {
+    [N in keyof LiveDirectives as `o:${N}` | `o:${N}-${LiveDirectives[N]['modifiers']}`]?: LiveDirectives[N]['value'];
+};
+/** `o:click="save"`: an action (a method, `method(args)`, `$refresh`, `$set(…)`, `$dispatch(…)`) on a DOM event. */
+type LiveEventAttributes = {
+    [E in LiveEvent as `o:${E}`]?: string;
+};
+type Letter = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+/**
+ * Every other attribute, with any value: each name that doesn't start with `o:` (`o`, `href`, `onclick`, `open`,
+ * `xlink:href`, `viewBox`; names with a `-`, such as `data-*`, `aria-*` and `hx-post`, are never checked).
+ */
+type OtherAttributes = {
+    [K in 'o' | `${Exclude<Letter, 'o'> | Uppercase<Letter> | '_' | '$'}${string}` | `o${Letter | Uppercase<Letter> | Digit | '_' | '.' | '$'}${string}`]?: unknown;
+};
+
 /**
  * The automatic JSX runtime (`jsxImportSource: "@orieljs/view"`). jsx() only describes elements; rendering
  * (escaping, async components) happens in renderToString()/renderToStream().
@@ -60,8 +147,13 @@ declare function renderToStream(node: Renderable): ReadableStream<Uint8Array>;
 declare function jsx(type: ElementType, props: Props | null, key?: string | number): OrielElement;
 /** Same as jsx(); the compiler uses it when there are several static children. */
 declare const jsxs: typeof jsx;
-/** Attributes every intrinsic element accepts. Unknown attributes (hx-*, x-*, o:click, …) are allowed. */
-interface HtmlAttributes {
+/**
+ * Attributes every intrinsic element accepts. Any attribute is allowed (hx-*, x-*, data-*, …) except an `o:` name
+ * that isn't a Live directive or `o:<event>` (directives.ts), so a typo such as `o:clik` doesn't compile. An `o:` form
+ * with a `-` that the type doesn't list compiles unchecked (TypeScript doesn't check a hyphenated JSX name the type
+ * leaves out), and a custom event name is spread: `<div {...{ 'o:saved': 'refresh' }} />`.
+ */
+interface HtmlAttributes extends OtherAttributes, LiveDirectiveAttributes, LiveEventAttributes {
     children?: Renderable;
     class?: ClassValue;
     className?: ClassValue;
@@ -69,7 +161,6 @@ interface HtmlAttributes {
     dangerouslySetInnerHTML?: {
         __html: string;
     };
-    [attribute: string]: unknown;
 }
 declare namespace JSX {
     type Element = OrielElement;
@@ -206,4 +297,4 @@ declare class ViewServiceProvider extends ServiceProvider {
     register(): void;
 }
 
-export { type ClassValue as C, ELEMENT as E, FileViewFinder as F, type HtmlAttributes as H, InvalidViewError as I, JSX as J, type OrielElement as O, type Props as P, type Renderable as R, type StyleObject as S, TsxView as T, View as V, Fragment as a, HtmlString as b, type Component as c, type ViewEnvironment as d, Factory as e, ViewNotFoundError as f, ViewRenderError as g, ViewServiceProvider as h, classNames as i, createElement as j, csrfField as k, e as l, isElement as m, isHtmlable as n, methodField as o, renderToStream as p, renderToString as q, raw as r, styleString as s, jsx as t, jsxs as u, view as v };
+export { type ClassValue as C, ELEMENT as E, FileViewFinder as F, type HtmlAttributes as H, InvalidViewError as I, JSX as J, type LiveDirectives as L, type OrielElement as O, type Props as P, type Renderable as R, type StyleObject as S, TsxView as T, View as V, Fragment as a, HtmlString as b, type LiveEvent as c, type Component as d, type ViewEnvironment as e, Factory as f, ViewNotFoundError as g, ViewRenderError as h, ViewServiceProvider as i, classNames as j, createElement as k, csrfField as l, e as m, isElement as n, isHtmlable as o, methodField as p, renderToStream as q, raw as r, renderToString as s, styleString as t, jsx as u, view as v, jsxs as w };

package/dist/jsx-runtime.d.ts

@@ -1,3 +1,3 @@
-export { a as Fragment, H as HtmlAttributes, J as JSX, t as jsx, u as jsxs } from './jsx-runtime-CBZQYYDS.js';
+export { a as Fragment, H as HtmlAttributes, J as JSX, u as jsx, w as jsxs } from './jsx-runtime-6um4Mwfb.js';
 import './contracts.js';
-import './index.d-BJyJx6U1.js';
+import './index.d-WQpfdIbG.js';

package/dist/jsx-runtime.js

@@ -2,9 +2,9 @@ import {
   Fragment,
   jsx,
   jsxs
-} from "./chunk-MFTZQMZM.js";
-import "./chunk-POEP4B2M.js";
-import "./chunk-I63ZFMX6.js";
+} from "./chunk-VOYW3R5J.js";
+import "./chunk-7ZQZYDOC.js";
+import "./chunk-GVNLZZTN.js";
 export {
   Fragment,
   jsx,

package/dist/{testing-BM481Hdz.d.ts → testing-CKwfWJGn.d.ts}

@@ -1,5 +1,5 @@
-import { BusDispatcher, Job, PendingBatchOptions, Class, PendingChain, PendingBatch, Batch, EventDispatcher, Listener, MailManager, Mailable, Address, MailRecipient, Mailer, PendingMail, SentMessage, MailTransport, NotificationDispatcher, Notifiable, Notification, NotificationChannel, QueueManager, QueuePayload, Queue, QueueJob, FilesystemManager, Filesystem, PutOptions, UploadedFile, Application, Session, View, Authenticatable, Container, AuthFactory, InertiaPage, ServiceProvider, ServiceProviderClass, DatabaseManager, ModelInstance, Row, Encrypter, Token, ExceptionHandler, ViewFactory, Rules, MessageBag, LiveSnapshot, LiveEffects, OrielError, ErrorKind, Htmlable, LiveManager, HttpRequest, LiveUpdateRequest, LiveUpdateResponse, MiddlewareClass, Router } from './contracts.js';
-import { S as ServiceProvider$1 } from './index.d-BJyJx6U1.js';
+import { BusDispatcher, Job, PendingBatchOptions, Class, PendingChain, PendingBatch, Batch, EventDispatcher, Listener, MailManager, Mailable, Address, MailRecipient, Mailer, PendingMail, SentMessage, MailTransport, NotificationDispatcher, Notifiable, Notification, NotificationChannel, QueueManager, QueuePayload, Queue, QueueJob, FilesystemManager, Filesystem, PutOptions, UploadedFile, Application, Session, View, Authenticatable, Container, AuthFactory, InertiaPage, ServiceProvider, ServiceProviderClass, DatabaseManager, ModelInstance, Row, Encrypter, Token, ExceptionHandler, ViewFactory, RouteName, RouteArguments, Rules, InferValidatedType, MessageBag, LiveSnapshot, LiveEffects, OrielError, ErrorKind, Htmlable, LiveManager, HttpRequest, LiveUpdateRequest, LiveUpdateResponse, MiddlewareClass, Router } from './contracts.js';
+import { S as ServiceProvider$1 } from './index.d-WQpfdIbG.js';
 
 /** A date the tests travel to: a Date, an ISO string or milliseconds since the epoch. */
 type TravelDate = Date | string | number;
@@ -417,6 +417,11 @@ declare class HttpClient {
     defaultGuard: string | undefined;
     /** Session attributes carried from one request to the next (Laravel keeps one session store per test). */
     session: Record<string, unknown> | undefined;
+    /**
+     * withSession() and flushSession() since the last started session: applied to the stored session (the one the
+     * session cookie points to) once the next request starts it, so they win over what it holds, as in Laravel.
+     */
+    sessionChanges: Array<(session: Session) => void>;
     /** from(url): the session's previous URL for the next request only (Laravel sets it once). */
     previousUrl: string | undefined;
     /** Requests whose actingAs users reached the guards (the AuthFactory they went through). */
@@ -442,6 +447,10 @@ declare class HttpClient {
      * request sticks. Reads each actingAs guard back and forgets or replaces its user to match.
      */
     protected syncActingAs(auth: AuthFactory): Promise<void>;
+    /** Applies the pending withSession()/flushSession() changes once the session has loaded what it stored. */
+    protected applyOnStart(session: Session): void;
+    /** Applies the pending withSession()/flushSession() changes to the session, once. */
+    protected applyPending(session: Session): void;
     /** The request's (scoped) Session, created now so the carried attributes are in place before StartSession. */
     protected scopeSession(scope: Container): Session | undefined;
     buildRequest(method: string, uri: string, options: RequestOptions): Request;
@@ -538,9 +547,9 @@ declare abstract class MakesHttpRequests extends InteractsWithApplication {
     followingRedirects(): this;
     /** Sets the Referer and the session's previous URL, so redirect()->back() goes there. */
     from(url: string): this;
-    /** Puts data in the session for the following requests (Laravel's withSession()). */
+    /** Puts data in the session for the following requests, over what the stored session holds (Laravel's withSession()). */
     withSession(data: Record<string, unknown>): this;
-    /** Empties the session carried between requests. */
+    /** Empties the session, the stored one included, so the next request starts with none (Laravel's flushSession()). */
     flushSession(): this;
     /** Every following request is authenticated as `user` on `guard` (which also becomes the default guard). */
     actingAs(user: Authenticatable, guard?: string): this;
@@ -1082,8 +1091,11 @@ interface QueuedDispatch {
 }
 /** The validation errors of a component (Laravel's MessageBag), for render(): `this.errors.first('title')`. */
 declare class ErrorBag implements MessageBag {
+    #private;
     private readonly messages;
     constructor(messages: Record<string, string[]>);
+    /** Adds to the component's errors, as addError() does. */
+    add(key: string, message: string): void;
     has(key: string): boolean;
     first(key?: string): string | undefined;
     get(key: string): string[];
@@ -1114,6 +1126,13 @@ declare abstract class Component {
     static layout?: string;
     /** The page title passed to the layout as `title`. */
     static title?: string;
+    /**
+     * Livewire's #[Lazy]: every embed (and the full page) renders the placeholder first and mounts once the browser shows
+     * it. `<Live component={…} lazy={false} />` mounts one at once. The placeholder is the component's
+     * `placeholder(params)` method (TSX), else the `live.lazy_placeholder` view, else an empty `<div>`: give it the root
+     * element the component renders.
+     */
+    static lazy?: boolean;
     /** Static fallbacks for runtimes without decorators: { event: 'method' }, locked names, computed getter names. */
     static listeners?: Record<string, string>;
     static locked?: string[];
@@ -1127,14 +1146,19 @@ declare abstract class Component {
     redirect(url: string, options?: {
         navigate?: boolean;
     }): void;
-    redirectRoute(name: string, parameters?: unknown, options?: {
+    /**
+     * redirect() to a named route: `this.redirectRoute('posts.show', post, { navigate: true })`. Once `oriel
+     * route:types` has run, the name and the route's parameters are checked, as route()'s are.
+     */
+    redirectRoute<N extends RouteName>(name: N, ...args: RouteArguments<N, [options?: {
         navigate?: boolean;
-    }): void;
+    }]>): void;
     /**
-     * Validates the public state. On success clears the error bag and returns the validated data; on failure fills the
-     * error bag and throws (the rest of the action is skipped and the component re-renders with `errors`).
+     * Validates the public state. On success clears the error bag and returns the validated data, typed from the rules
+     * (`await this.validate({ title: 'required|string' })` is `{ title: string }`); on failure fills the error bag and
+     * throws (the rest of the action is skipped and the component re-renders with `errors`).
      */
-    validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
+    validate<const R extends Rules>(rules: R, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<InferValidatedType<R>>;
     addError(key: string, message: string): void;
     /** Clears every error, or only those of `keys`. */
     resetErrorBag(...keys: string[]): void;
@@ -1178,7 +1202,10 @@ declare class Testable<C extends Component = Component> {
     private readonly manager;
     private readonly scope;
     private constructor();
-    /** Mounts `component` with `params`, as `<Live component={…} {...params} />` would. */
+    /**
+     * Mounts `component` with `params`, as `<Live component={…} {...params} />` would. A lazy component mounts at once
+     * (Livewire's withoutLazyLoading()); `{ lazy: true }` renders its placeholder, and `call('__lazyLoad', …)` loads it.
+     */
     static create<C extends Component>(component: Class<C> | string, params?: Record<string, unknown>): Promise<Testable<C>>;
     /** The component instance after the last request. */
     instance(): C;
@@ -1188,7 +1215,14 @@ declare class Testable<C extends Component = Component> {
     html(): string;
     /** The effects of the last request. */
     effects(): LiveEffects;
+    /**
+     * Sets public properties through an update. A file (a FakeFile) or an array of files is uploaded as `o:model` on a
+     * file input does it: the upload rules, the temporary disk, then a TemporaryUploadedFile (or an array) in the
+     * property, or the upload's errors on it (Livewire's).
+     */
     set(path: string | Record<string, unknown>, value?: unknown): Promise<this>;
+    /** Uploads `files` into the property `name` (an array when `multiple`), as the browser's upload calls do. */
+    upload(name: string, files: readonly Blob[], multiple?: boolean): Promise<this>;
     call(method: string, ...params: unknown[]): Promise<this>;
     toggle(path: string): Promise<this>;
     /** Dispatches an event to this component, as the browser does for its listeners. */
@@ -1221,6 +1255,11 @@ interface LiveProps {
     component: Class<Component> | string;
     /** Identifies a child inside its parent across re-renders (Livewire's :key / wire:key). */
     'o:key'?: string | number;
+    /**
+     * Renders the placeholder and mounts the component once it scrolls into view (`'on-load'`: once the page starts);
+     * `false` mounts a `static lazy` component at once.
+     */
+    lazy?: boolean | 'on-load';
     [param: string]: unknown;
 }
 /** Blade's @livewire('counter', ['count' => 3], key('c1')): the component's first render, as trusted HTML. */
@@ -1263,10 +1302,25 @@ declare class LiveComponentManager implements LiveManager {
     isLiveRequest(request: HttpRequest): boolean;
     /** The first render: HTML with o:id, o:snapshot and o:effects on the root element. */
     mount(component: string | Class<unknown>, params?: Record<string, unknown>, key?: string): Promise<string>;
-    mountComponent(component: string | Class<unknown>, params?: Record<string, unknown>, existing?: Component): Promise<ComponentResult>;
+    /**
+     * Mounts a component: boot(), the params into its properties, mount(params), then its first render. A lazy one
+     * (`lazy` in the params, or `static lazy`) renders its placeholder instead and mounts when the browser loads it.
+     */
+    mountComponent(component: string | Class<unknown>, embedParams?: Record<string, unknown>, existing?: Component): Promise<ComponentResult>;
+    /**
+     * A lazy component's first render (Livewire's): its placeholder, with the state it has before mount() and the mount
+     * params signed for the `__lazyLoad` call the browser makes when it shows it (`o:lazy`, or `o:lazy-on-load`).
+     */
+    private mountPlaceholder;
     /** Applies each component's updates and calls, re-renders it and returns its new snapshot and effects. */
     update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
     updateComponent(snapshotJson: string, updates: Record<string, unknown>, calls: Call[]): Promise<ComponentResult>;
+    /**
+     * The mount params and placeholder tag of a `__lazyLoad` request, or undefined for any other update. The load comes
+     * alone (no updates, no other call: the browser sends it in a request of its own) and its payload must be the one
+     * signed for this component: anything else is refused as corrupt (a 403) before the component boots.
+     */
+    private lazyLoad;
     /**
      * The route action of POST /oriel/live/update. Each component's update runs behind the persistent middleware of the
      * route that rendered its page (Livewire's): `auth`, `verified`, `guest` and `can`, with the page route's parameters
@@ -1285,7 +1339,7 @@ declare class LiveComponentManager implements LiveManager {
     /** Makes every computed getter (static `computed` too) cache its value for the rest of the request. */
     private prepareComputed;
     private applyUpdate;
-    /** Runs one call from the browser: a magic action, an event, or a public method. Returns its return value. */
+    /** Runs one call from the browser: a magic action, an event, an upload call, or a public method. Returns its return value. */
     private call;
     /**
      * Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. A
@@ -1305,8 +1359,9 @@ declare class LiveComponentManager implements LiveManager {
 declare const UPDATE_URI = "/oriel/live/update";
 /**
  * Binds the LiveManager and the PaginationState that WithPagination components answer, merges the `live` config,
- * registers POST /oriel/live/update (named `live.update`, in the `web` group: sessions and CSRF apply), the make:live
- * command, and the components under app/Live.
+ * registers POST /oriel/live/update (named `live.update`, in the `web` group: sessions and CSRF apply), the upload and
+ * preview routes of WithFileUploads (`live.upload-file`, `live.preview-file`), the make:live command, and the
+ * components under app/Live.
  */
 declare class LiveServiceProvider extends ServiceProvider$1 {
     register(): void;
@@ -1356,6 +1411,108 @@ declare class InvalidLiveRequestError extends LiveError {
     readonly kind: ErrorKind;
     readonly status: number;
 }
+/** An upload or preview URL whose signature is missing, wrong or expired (Livewire's 401). Nothing is read or stored. */
+declare class InvalidUploadSignatureError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor();
+}
+/** A preview of a temporary upload that is no longer on the disk (cleaned up, or stored and deleted). */
+declare class TemporaryFileNotFoundError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor(filename: string);
+}
+/** temporaryUrl() on an upload whose type has no preview (live.temporary_file_upload.preview_mimes). */
+declare class FileNotPreviewableError extends LiveError {
+    readonly name: string;
+    constructor(extension: string);
+}
+/** The errors an upload came back with (`_uploadErrored`): the component re-renders with them on the property. */
+declare class UploadValidationError extends LiveError {
+    readonly errors: Record<string, string[]>;
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    readonly errorBag: string;
+    constructor(errors: Record<string, string[]>);
+}
+
+/**
+ * Livewire's `temporary_file_upload` settings, read from config `live.temporary_file_upload.*` (each one falls back on
+ * its own): the disk (the default filesystem disk), the directory on it, the rules every upload must pass, the upload
+ * route's middleware, the types a preview is served for, how long an upload URL lasts (minutes), and whether a finished
+ * upload removes the temporary files older than a day.
+ */
+declare const TEMPORARY_UPLOAD_DEFAULTS: {
+    disk: string | null;
+    directory: string;
+    rules: string | string[];
+    middleware: string | string[];
+    preview_mimes: string[];
+    max_upload_time: number;
+    cleanup: boolean;
+};
+/** What a temporary upload is: its stored name on the temporary disk and what the browser sent (signed with it). */
+interface TemporaryFileData {
+    /** A random 40-character name with the extension its bytes showed: `live-tmp/<filename>` on the temporary disk. */
+    filename: string;
+    /** The name the browser gave the file. */
+    name: string;
+    size: number;
+    /** The MIME type the browser claimed. */
+    type: string;
+    /** The extension of the upload's own type (its bytes, else a plain claimed extension), or ''. */
+    extension: string;
+}
+/**
+ * Livewire's TemporaryUploadedFile: a file the browser uploaded to the temporary directory before an action stores
+ * it. A WithFileUploads component's property holds one (or an array of them) once `o:model` on a file input has
+ * uploaded it: validate it like any upload (`'photo' => 'image|max:1024'`), preview it with `temporaryUrl()`, then
+ * `store()` it. It travels in the component's snapshot as its data, signed with the rest.
+ */
+declare class TemporaryUploadedFile implements UploadedFile {
+    #private;
+    readonly filename: string;
+    readonly clientName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    constructor(data: TemporaryFileData);
+    /** What the snapshot carries. */
+    toData(): TemporaryFileData;
+    /** The file's path on the temporary disk. */
+    get path(): string;
+    /** The extension of the upload's own type, as FormUploadedFile's extension(): what putFile() names a stored copy by. */
+    extension(): string;
+    /** The extension of the name the browser gave the file, lower-cased ('' without one). */
+    clientExtension(): string;
+    /** A random 40-character name with extension(), as FormUploadedFile's. */
+    hashName(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    /** The file's bytes from the temporary disk, opened on the first read. */
+    stream(): ReadableStream<Uint8Array>;
+    /** Stores a copy under a random name in `directory`, on `disk` (by default the temporary disk, as Livewire's). */
+    store(directory: string, disk?: string): Promise<string>;
+    storeAs(directory: string, name: string, disk?: string): Promise<string>;
+    exists(): Promise<boolean>;
+    /** Removes the temporary file (a stored copy stays). */
+    delete(): Promise<boolean>;
+    /** Whether temporaryUrl() serves this file: its type is in `live.temporary_file_upload.preview_mimes`. */
+    isPreviewable(): boolean;
+    /**
+     * A signed link to the file for `<img src>` or `<video src>` before it is stored. It lasts until the end of the hour
+     * at least 30 minutes away (Livewire's), so a re-render keeps the same link and the browser doesn't reload it.
+     */
+    temporaryUrl(): string;
+}
+
+/** Where the browser POSTs a WithFileUploads component's files (Livewire's /livewire/upload-file), named live.upload-file. */
+declare const UPLOAD_URI = "/oriel/live/upload-file";
+/** Where temporaryUrl() links lead (Livewire's /livewire/preview-file/{filename}), named live.preview-file. */
+declare const PREVIEW_URI = "/oriel/live/preview-file";
 
 /** The route middleware an update re-applies by default (config live.persistent_middleware), by alias. */
 declare const PERSISTENT_MIDDLEWARE: string[];
@@ -1391,6 +1548,14 @@ interface Paginated {
  */
 declare function WithPagination<TBase extends ComponentConstructor>(Base: TBase): TBase & (abstract new (...args: any[]) => Paginated);
 
+/**
+ * Livewire's WithFileUploads: `class Profile extends WithFileUploads(Component)`. A file input with `o:model="photo"`
+ * uploads the file to the temporary directory as soon as it is picked, then sets `photo` to a TemporaryUploadedFile
+ * (`<input type="file" multiple>` sets an array), through `updatingPhoto()`/`updatedPhoto()` like any update. Validate
+ * it with the file rules, preview it with `temporaryUrl()`, store it with `store()`.
+ */
+declare function WithFileUploads<TBase extends ComponentConstructor>(Base: TBase): TBase;
+
 /**
  * What <Pagination> reads from a paginator. Structural, since Live can't import Database: paginate()'s
  * LengthAwarePaginator (with lastPage(), so page buttons) and simplePaginate()'s Paginator (Previous and Next only).
@@ -1418,4 +1583,4 @@ interface PaginationProps {
  */
 declare function Pagination({ paginator, class: className }: PaginationProps): Htmlable;
 
-export { InteractsWithDatabase as $, AnonymousNotifiable as A, BusFake as B, Component as C, type CountOrFilter as D, EventFake as E, DatabaseMigrations as F, type DatabaseTestOptions as G, DatabaseTransactions as H, InvalidLiveRequestError as I, type DispatchedEvent as J, type ExpectedErrors as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, type ExpectedListener as R, StorageFake as S, TestRequestScope as T, UPDATE_URI as U, FakeDisk as V, WithPagination as W, FakeFile as X, HttpClient as Y, InteractsWithApplication as Z, InteractsWithConsole as _, type ComponentResult as a, InteractsWithTime as a0, type JsonStructure as a1, MailRecord as a2, MakesHttpRequests as a3, PendingCommand as a4, type PushedJob as a5, RefreshDatabase as a6, RefreshDatabaseState as a7, type RequestData as a8, type RequestOptions as a9, matches as aA, nameOf as aB, recordingExceptionHandler as aC, recordingViewFactory as aD, responseCookies as aE, runCommand as aF, travel as aG, travelBack as aH, travelTo as aI, usingInMemoryDatabase as aJ, type ResponseContext as aa, type ResponseCookie as ab, type SentNotification as ac, TESTING_ENVIRONMENT as ad, type TableOrModel as ae, type Target as af, TestCase as ag, type TestHooks as ah, TestResponse as ai, type TestTrait as aj, type TravelDate as ak, Wormhole as al, actingAsAuthFactory as am, addresses as an, applyEnvironment as ao, cookieHeader as ap, cookiePrefix as aq, decryptCookie as ar, encryptCookie as as, flatten as at, freezeSecond as au, freezeTime as av, guessMimeType as aw, inertiaPageOf as ax, install as ay, isExpired as az, Computed as b, CorruptComponentPayloadError as c, ErrorBag as d, LiveComponentManager as e, LiveComponentNotFoundError as f, LiveError as g, type LiveProps as h, LiveServiceProvider as i, Locked as j, MethodNotCallableError as k, type Paginated as l, Pagination as m, type PaginationProps as n, type PaginationSource as o, PendingEvent as p, type PersistentMiddleware as q, PropertyNotUpdatableError as r, Testable as s, componentName as t, live as u, persistentMiddleware as v, AssertableInertia as w, AssertableJson as x, type BatchRecord as y, type BootOptions as z };
+export { type DatabaseTestOptions as $, UploadValidationError as A, BusFake as B, Component as C, WithPagination as D, EventFake as E, FileNotPreviewableError as F, componentName as G, live as H, InvalidLiveRequestError as I, persistentMiddleware as J, AnonymousNotifiable as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, AssertableInertia as R, StorageFake as S, TEMPORARY_UPLOAD_DEFAULTS as T, UPDATE_URI as U, AssertableJson as V, WithFileUploads as W, type BatchRecord as X, type BootOptions as Y, type CountOrFilter as Z, DatabaseMigrations as _, type ComponentResult as a, DatabaseTransactions as a0, type DispatchedEvent as a1, type ExpectedErrors as a2, type ExpectedListener as a3, FakeDisk as a4, FakeFile as a5, HttpClient as a6, InteractsWithApplication as a7, InteractsWithConsole as a8, InteractsWithDatabase as a9, cookiePrefix as aA, decryptCookie as aB, encryptCookie as aC, flatten as aD, freezeSecond as aE, freezeTime as aF, guessMimeType as aG, inertiaPageOf as aH, install as aI, isExpired as aJ, matches as aK, nameOf as aL, recordingExceptionHandler as aM, recordingViewFactory as aN, responseCookies as aO, runCommand as aP, travel as aQ, travelBack as aR, travelTo as aS, usingInMemoryDatabase as aT, InteractsWithTime as aa, type JsonStructure as ab, MailRecord as ac, MakesHttpRequests as ad, PendingCommand as ae, type PushedJob as af, RefreshDatabase as ag, RefreshDatabaseState as ah, type RequestData as ai, type RequestOptions as aj, type ResponseContext as ak, type ResponseCookie as al, type SentNotification as am, TESTING_ENVIRONMENT as an, type TableOrModel as ao, type Target as ap, TestCase as aq, type TestHooks as ar, TestResponse as as, type TestTrait as at, type TravelDate as au, Wormhole as av, actingAsAuthFactory as aw, addresses as ax, applyEnvironment as ay, cookieHeader as az, Computed as b, CorruptComponentPayloadError as c, ErrorBag as d, InvalidUploadSignatureError as e, LiveComponentManager as f, LiveComponentNotFoundError as g, LiveError as h, type LiveProps as i, LiveServiceProvider as j, Locked as k, MethodNotCallableError as l, PREVIEW_URI as m, type Paginated as n, Pagination as o, type PaginationProps as p, type PaginationSource as q, PendingEvent as r, type PersistentMiddleware as s, PropertyNotUpdatableError as t, type TemporaryFileData as u, TemporaryFileNotFoundError as v, TemporaryUploadedFile as w, TestRequestScope as x, Testable as y, UPLOAD_URI as z };

package/dist/testing.d.ts

@@ -1,3 +1,3 @@
-export { A as AnonymousNotifiable, w as AssertableInertia, x as AssertableJson, y as BatchRecord, z as BootOptions, B as BusFake, D as CountOrFilter, F as DatabaseMigrations, G as DatabaseTestOptions, H as DatabaseTransactions, J as DispatchedEvent, E as EventFake, K as ExpectedErrors, R as ExpectedListener, V as FakeDisk, X as FakeFile, Y as HttpClient, Z as InteractsWithApplication, _ as InteractsWithConsole, $ as InteractsWithDatabase, a0 as InteractsWithTime, a1 as JsonStructure, L as Live, M as MailFake, a2 as MailRecord, a3 as MakesHttpRequests, N as NotificationFake, a4 as PendingCommand, a5 as PushedJob, Q as QueueFake, a6 as RefreshDatabase, a7 as RefreshDatabaseState, a8 as RequestData, a9 as RequestOptions, aa as ResponseContext, ab as ResponseCookie, ac as SentNotification, S as StorageFake, ad as TESTING_ENVIRONMENT, ae as TableOrModel, af as Target, ag as TestCase, ah as TestHooks, ai as TestResponse, aj as TestTrait, s as Testable, ak as TravelDate, al as Wormhole, am as actingAsAuthFactory, an as addresses, ao as applyEnvironment, ap as cookieHeader, aq as cookiePrefix, ar as decryptCookie, as as encryptCookie, at as flatten, au as freezeSecond, av as freezeTime, aw as guessMimeType, ax as inertiaPageOf, ay as install, az as isExpired, aA as matches, aB as nameOf, aC as recordingExceptionHandler, aD as recordingViewFactory, aE as responseCookies, aF as runCommand, aG as travel, aH as travelBack, aI as travelTo, aJ as usingInMemoryDatabase } from './testing-BM481Hdz.js';
+export { K as AnonymousNotifiable, R as AssertableInertia, V as AssertableJson, X as BatchRecord, Y as BootOptions, B as BusFake, Z as CountOrFilter, _ as DatabaseMigrations, $ as DatabaseTestOptions, a0 as DatabaseTransactions, a1 as DispatchedEvent, E as EventFake, a2 as ExpectedErrors, a3 as ExpectedListener, a4 as FakeDisk, a5 as FakeFile, a6 as HttpClient, a7 as InteractsWithApplication, a8 as InteractsWithConsole, a9 as InteractsWithDatabase, aa as InteractsWithTime, ab as JsonStructure, L as Live, M as MailFake, ac as MailRecord, ad as MakesHttpRequests, N as NotificationFake, ae as PendingCommand, af as PushedJob, Q as QueueFake, ag as RefreshDatabase, ah as RefreshDatabaseState, ai as RequestData, aj as RequestOptions, ak as ResponseContext, al as ResponseCookie, am as SentNotification, S as StorageFake, an as TESTING_ENVIRONMENT, ao as TableOrModel, ap as Target, aq as TestCase, ar as TestHooks, as as TestResponse, at as TestTrait, y as Testable, au as TravelDate, av as Wormhole, aw as actingAsAuthFactory, ax as addresses, ay as applyEnvironment, az as cookieHeader, aA as cookiePrefix, aB as decryptCookie, aC as encryptCookie, aD as flatten, aE as freezeSecond, aF as freezeTime, aG as guessMimeType, aH as inertiaPageOf, aI as install, aJ as isExpired, aK as matches, aL as nameOf, aM as recordingExceptionHandler, aN as recordingViewFactory, aO as responseCookies, aP as runCommand, aQ as travel, aR as travelBack, aS as travelTo, aT as usingInMemoryDatabase } from './testing-CKwfWJGn.js';
 import './contracts.js';
-import './index.d-BJyJx6U1.js';
+import './index.d-WQpfdIbG.js';

package/dist/testing.js

@@ -52,9 +52,9 @@ import {
   travelBack,
   travelTo,
   usingInMemoryDatabase
-} from "./chunk-ZOEPKBVF.js";
-import "./chunk-POEP4B2M.js";
-import "./chunk-I63ZFMX6.js";
+} from "./chunk-SPQUX3C7.js";
+import "./chunk-7ZQZYDOC.js";
+import "./chunk-GVNLZZTN.js";
 export {
   AnonymousNotifiable,
   AssertableInertia,