@orieljs/framework 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/jsx-runtime.js

@@ -2,9 +2,9 @@ import {
   Fragment,
   jsx,
   jsxs
-} from "./chunk-WEGTH46M.js";
-import "./chunk-HU43NADT.js";
-import "./chunk-S7YC43IH.js";
+} from "./chunk-A5XRLEWM.js";
+import "./chunk-PM5YTG57.js";
+import "./chunk-BSQKOLSK.js";
 export {
   Fragment,
   jsx,

package/dist/{testing--F6FODc_.d.ts → testing-BErengYY.d.ts}

@@ -37,6 +37,44 @@ interface Container$1 {
 }
 declare const Container$1: Token$1<Container$1>;
 
+/** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
+interface Session$1 {
+    getId(): string;
+    start(): Promise<void>;
+    save(): Promise<void>;
+    all(): Record<string, unknown>;
+    has(key: string): boolean;
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    put(key: string | Record<string, unknown>, value?: unknown): void;
+    push(key: string, value: unknown): void;
+    pull<T = unknown>(key: string, defaultValue?: T): T;
+    forget(...keys: string[]): void;
+    flush(): void;
+    flash(key: string, value: unknown): void;
+    now(key: string, value: unknown): void;
+    reflash(): void;
+    keep(...keys: string[]): void;
+    getOldInput<T = unknown>(key?: string, defaultValue?: T): T;
+    flashInput(input: Record<string, unknown>): void;
+    token(): string;
+    regenerateToken(): void;
+    regenerate(destroy?: boolean): Promise<void>;
+    invalidate(): Promise<void>;
+    previousUrl(): string | undefined;
+    setPreviousUrl(url: string): void;
+}
+declare const Session$1: Token$2<Session$1>;
+interface UploadedFile$1 {
+    readonly clientName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    extension(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /** Stores on a Filesystem disk. Returns the stored path. */
+    store(directory: string, disk?: string): Promise<string>;
+    storeAs(directory: string, name: string, disk?: string): Promise<string>;
+}
+
 interface ServiceProvider$2 {
     /** Bind things into the container. Synchronous. Don't resolve other services here. */
     register?(): void;
@@ -98,44 +136,6 @@ interface Enumerable<T> extends Iterable<T>, Arrayable<unknown[]> {
     isEmpty(): boolean;
 }
 
-/** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
-interface Session$1 {
-    getId(): string;
-    start(): Promise<void>;
-    save(): Promise<void>;
-    all(): Record<string, unknown>;
-    has(key: string): boolean;
-    get<T = unknown>(key: string, defaultValue?: T): T;
-    put(key: string | Record<string, unknown>, value?: unknown): void;
-    push(key: string, value: unknown): void;
-    pull<T = unknown>(key: string, defaultValue?: T): T;
-    forget(...keys: string[]): void;
-    flush(): void;
-    flash(key: string, value: unknown): void;
-    now(key: string, value: unknown): void;
-    reflash(): void;
-    keep(...keys: string[]): void;
-    getOldInput<T = unknown>(key?: string, defaultValue?: T): T;
-    flashInput(input: Record<string, unknown>): void;
-    token(): string;
-    regenerateToken(): void;
-    regenerate(destroy?: boolean): Promise<void>;
-    invalidate(): Promise<void>;
-    previousUrl(): string | undefined;
-    setPreviousUrl(url: string): void;
-}
-declare const Session$1: Token$2<Session$1>;
-interface UploadedFile$1 {
-    readonly clientName: string;
-    readonly mimeType: string;
-    readonly size: number;
-    extension(): string;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    /** Stores on a Filesystem disk. Returns the stored path. */
-    store(directory: string, disk?: string): Promise<string>;
-    storeAs(directory: string, name: string, disk?: string): Promise<string>;
-}
-
 interface Encrypter {
     /** JSON-serializes unless serialize=false (then value must be a string). AES-256-GCM, keyed by APP_KEY. */
     encrypt(value: unknown, serialize?: boolean): string;
@@ -233,6 +233,8 @@ interface ModelInstance {
     getTable(): string;
     getRouteKey(): unknown;
     getRouteKeyName(): string;
+    /** The value stored in a polymorphic `*_type` column for this model: its morph map alias, else its class name. */
+    getMorphClass(): string;
     getAttribute<T = unknown>(key: string): T;
     setAttribute(key: string, value: unknown): this;
     fill(attributes: Row): this;
@@ -285,6 +287,11 @@ declare const AuthFactory: Token$2<AuthFactory>;
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -962,6 +969,12 @@ declare class HttpClient {
     request(method: string, uri: string, options?: RequestOptions): Promise<TestResponse>;
     /** Runs `fn` in a scope prepared like a request's (carried session, actingAs users), e.g. for assertAuthenticated(). */
     inScope<T>(fn: (scope: Container$1) => T | Promise<T>): Promise<T>;
+    /**
+     * Runs `run` in a request scope like this client's requests have (a request for `method uri` bound, the carried
+     * session, actingAs users), then carries the session and the users on, as after a request. Live.test() runs its
+     * mount and updates through it.
+     */
+    withinRequest<T>(run: () => Promise<T>, method?: string, uri?: string): Promise<T>;
     /** Runs the request through the app's real HttpKernel, in a request scope this client owns. */
     protected send(request: Request): Promise<TestResponse>;
     /** Prepares the request scope: recorders, the carried session and actingAs users. */
@@ -1035,6 +1048,11 @@ declare abstract class InteractsWithApplication {
     protected defineEnvironment(_app: Application$1): void | Promise<void>;
     setUp(): Promise<void>;
     tearDown(): Promise<void>;
+    /**
+     * Laravel's withoutVite(): in this test's requests vite([...]) and viteReactRefresh() render nothing, so feature
+     * tests of pages pass before `vite build` has written public/build/manifest.json.
+     */
+    withoutVite(): this;
     /** Runs in tearDown(), before the application is thrown away (in registration order). */
     beforeApplicationDestroyed(callback: Callback): void;
 }
@@ -1046,6 +1064,8 @@ declare abstract class MakesHttpRequests extends InteractsWithApplication {
     /** The current test's HTTP client (created on first use). */
     protected get http(): HttpClient;
     protected createHttpClient(): HttpClient;
+    /** Live.test() runs in this test's request scope (Live reads the same token: no import between the packages). */
+    setUp(): Promise<void>;
     tearDown(): Promise<void>;
     withHeaders(headers: Headers$1): this;
     withHeader(name: string, value: string): this;
@@ -1467,6 +1487,7 @@ interface StoredFile {
     mimeType: string | undefined;
     modified: Date;
 }
+/** By the extension as PHP's pathinfo() reads it: after the last dot of the base name ('.pdf' is a PDF, 'pdf' isn't). */
 declare function guessMimeType(path: string): string | undefined;
 /**
  * An in-memory disk implementing the Filesystem contract, with Laravel's fake-disk assertions. (Laravel's fake
@@ -1487,7 +1508,12 @@ declare class FakeDisk implements Filesystem {
     readStream(path: string): Promise<ReadableStream<Uint8Array>>;
     put(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: PutOptions): Promise<boolean>;
     putFile(directory: string, file: UploadedFile$1, options?: PutOptions): Promise<string>;
+    /**
+     * The upload's own type, as the S3 disk sends it: its extension(), never the MIME type the client sent as such nor
+     * the stored name's type.
+     */
     putFileAs(directory: string, file: UploadedFile$1, name: string, options?: PutOptions): Promise<string>;
+    private write;
     delete(paths: string | string[]): Promise<boolean>;
     copy(from: string, to: string): Promise<boolean>;
     move(from: string, to: string): Promise<boolean>;
@@ -1547,9 +1573,17 @@ declare class StorageFake implements FilesystemManager {
 
 /** Laravel's UploadedFile::fake(): File objects to post as multipart uploads (t.post(uri, { avatar: file })). */
 declare const FakeFile: {
-    /** A file of `kilobytes` KiB (zero bytes), typed by `mimeType` or the extension. */
+    /**
+     * A file of `kilobytes` KiB typed by `mimeType` or the name's extension. Validation reads a file's bytes, so the
+     * file starts like its type (a PDF's `%PDF-`, a PNG's signature, text for text types) and passes `mimes` for its
+     * name, as Laravel's fakes do. It is at least its type's leading bytes and never empty, whatever the size asked for.
+     * An image made this way has no readable size: use image() for `dimensions`.
+     */
     create(name: string, kilobytes?: number, mimeType?: string): File;
-    /** A real PNG image of the given size (typed by the name's extension, like Laravel's image()). */
+    /**
+     * A real white image of the given size in the format the name's extension asks for: png, jpg/jpeg, gif, webp or
+     * bmp (any other name gets a JPEG, as Laravel's fakes do), so image, mimes and dimensions pass on it.
+     */
     image(name: string, width?: number, height?: number): File;
 };
 
@@ -1589,50 +1623,6 @@ interface Container {
 }
 declare const Container: Token<Container>;
 
-interface ServiceProvider$1 {
-    /** Bind things into the container. Synchronous. Don't resolve other services here. */
-    register?(): void;
-    /** Runs after every provider is registered. May be async (e.g. importing route files). */
-    boot?(): void | Promise<void>;
-}
-type ServiceProviderClass = new (app: Application) => ServiceProvider$1;
-interface Application extends Container {
-    readonly version: string;
-    basePath(path?: string): string;
-    appPath(path?: string): string;
-    bootstrapPath(path?: string): string;
-    configPath(path?: string): string;
-    databasePath(path?: string): string;
-    publicPath(path?: string): string;
-    resourcePath(path?: string): string;
-    storagePath(path?: string): string;
-    /** With no args returns the environment name. With args returns whether it matches any of them. */
-    environment(): string;
-    environment(...environments: string[]): boolean;
-    isProduction(): boolean;
-    isLocal(): boolean;
-    runningInConsole(): boolean;
-    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
-    setRunningInConsole(value?: boolean): void;
-    runningUnitTests(): boolean;
-    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
-    register(provider: ServiceProvider$1 | ServiceProviderClass): Promise<ServiceProvider$1>;
-    getProviders(): ServiceProvider$1[];
-    boot(): Promise<void>;
-    isBooted(): boolean;
-    booting(callback: (app: Application) => void | Promise<void>): void;
-    booted(callback: (app: Application) => void | Promise<void>): void;
-    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
-    handle(request: Request): Promise<Response>;
-    /** Register a callback that terminate() runs, in registration order. */
-    terminating(callback: () => void | Promise<void>): void;
-    terminate(): Promise<void>;
-}
-declare const Application: Token$2<Application>;
-interface Htmlable {
-    toHtml(): string;
-}
-
 /** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
 interface Session {
     getId(): string;
@@ -1704,6 +1694,8 @@ interface HttpRequest {
     header(name: string, defaultValue: string): string;
     bearerToken(): string | undefined;
     ip(): string | undefined;
+    /** The raw body as text (Laravel's getContent()); '' when there is none. */
+    content(): string;
     expectsJson(): boolean;
     ajax(): boolean;
     query<T = unknown>(key?: string, defaultValue?: T): T;
@@ -1730,6 +1722,130 @@ interface HttpRequest {
     validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
 }
 declare const HttpRequest: Token$2<HttpRequest>;
+type Next = (request: HttpRequest) => Promise<Response>;
+interface Middleware {
+    handle(request: HttpRequest, next: Next, ...parameters: string[]): Promise<Response>;
+    terminate?(request: HttpRequest, response: Response): Promise<void>;
+}
+type MiddlewareClass = new (...args: any[]) => Middleware;
+
+interface ServiceProvider$1 {
+    /** Bind things into the container. Synchronous. Don't resolve other services here. */
+    register?(): void;
+    /** Runs after every provider is registered. May be async (e.g. importing route files). */
+    boot?(): void | Promise<void>;
+}
+type ServiceProviderClass = new (app: Application) => ServiceProvider$1;
+interface Application extends Container {
+    readonly version: string;
+    basePath(path?: string): string;
+    appPath(path?: string): string;
+    bootstrapPath(path?: string): string;
+    configPath(path?: string): string;
+    databasePath(path?: string): string;
+    publicPath(path?: string): string;
+    resourcePath(path?: string): string;
+    storagePath(path?: string): string;
+    /** With no args returns the environment name. With args returns whether it matches any of them. */
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    isProduction(): boolean;
+    isLocal(): boolean;
+    runningInConsole(): boolean;
+    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
+    setRunningInConsole(value?: boolean): void;
+    runningUnitTests(): boolean;
+    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
+    register(provider: ServiceProvider$1 | ServiceProviderClass): Promise<ServiceProvider$1>;
+    getProviders(): ServiceProvider$1[];
+    boot(): Promise<void>;
+    isBooted(): boolean;
+    booting(callback: (app: Application) => void | Promise<void>): void;
+    booted(callback: (app: Application) => void | Promise<void>): void;
+    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
+    handle(request: Request): Promise<Response>;
+    /** Register a callback that terminate() runs, in registration order. */
+    terminating(callback: () => void | Promise<void>): void;
+    terminate(): Promise<void>;
+}
+declare const Application: Token$2<Application>;
+interface Htmlable {
+    toHtml(): string;
+}
+
+/** Public method names of a controller (excludes non-function members). */
+type ActionMethods<C> = {
+    [K in keyof C]: C[K] extends (...args: any[]) => unknown ? K : never;
+}[keyof C] & string;
+type ControllerAction<C> = readonly [Class<C>, ActionMethods<C>];
+type RouteClosure = (...args: any[]) => unknown;
+/** A class with __invoke(): Route.get('/counter', Counter) (single-action controllers, full-page Live components). */
+type InvokableClass = Class<{
+    __invoke(...args: any[]): unknown;
+}>;
+type RouteAction = RouteClosure | ControllerAction<any> | InvokableClass;
+type MiddlewareReference = string | MiddlewareClass;
+interface Route {
+    readonly methods: readonly string[];
+    readonly uri: string;
+    getName(): string | undefined;
+    name(name: string): this;
+    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): this;
+    withoutMiddleware(...middleware: MiddlewareReference[]): this;
+    where(parameter: string, pattern: string): this;
+    where(patterns: Record<string, string>): this;
+}
+interface RouteRegistrar {
+    prefix(prefix: string): RouteRegistrar;
+    name(prefix: string): RouteRegistrar;
+    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): RouteRegistrar;
+    controller(controller: Class<unknown>): RouteRegistrar;
+    group(routes: () => void | Promise<void>): Promise<void>;
+}
+interface ResourceOptions {
+    only?: string[];
+    except?: string[];
+    parameters?: Record<string, string>;
+    names?: Record<string, string>;
+}
+interface Router {
+    get<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    post<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    put<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    patch<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    delete<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    options<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    any<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    match<C>(methods: string[], uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    redirect(from: string, to: string, status?: number): Route;
+    view(uri: string, view: string, data?: Record<string, unknown>): Route;
+    /** Route.inertia('/about', 'About', props): a GET route that renders an Inertia page (Laravel's Route::inertia). */
+    inertia(uri: string, component: string, props?: Record<string, unknown>): Route;
+    resource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
+    apiResource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
+    fallback(action: RouteAction): Route;
+    prefix(prefix: string): RouteRegistrar;
+    name(prefix: string): RouteRegistrar;
+    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): RouteRegistrar;
+    controller(controller: Class<unknown>): RouteRegistrar;
+    /** Explicit model binding: Route.model('author', User). */
+    model(parameter: string, model: Class<unknown>): void;
+    /** Custom binding resolver. */
+    bind(parameter: string, resolver: (value: string) => unknown | Promise<unknown>): void;
+    pattern(parameter: string, pattern: string): void;
+    /** Name a middleware class, e.g. aliasMiddleware('auth', Authenticate). */
+    aliasMiddleware(name: string, middleware: MiddlewareClass): this;
+    /** Define (or replace) a middleware group such as 'web' or 'api'. */
+    middlewareGroup(name: string, middleware: MiddlewareReference[]): this;
+    /** Append to a group unless it is already present. */
+    pushMiddlewareToGroup(group: string, middleware: MiddlewareReference): this;
+    getMiddlewareGroups(): Record<string, MiddlewareReference[]>;
+    getRoutes(): readonly Route[];
+    current(): Route | undefined;
+    /** Match the request, bind parameters, run the route middleware and the action. Called by the Http kernel. */
+    dispatch(request: HttpRequest): Promise<Response>;
+}
+declare const Router: Token$2<Router>;
 
 type ErrorKind = 'Http' | 'Server' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
 /** Every error thrown by the framework implements this. The exception handler switches on `kind`. */
@@ -1894,13 +2010,22 @@ declare function Locked(_target: unknown, context: ClassFieldDecoratorContext |
 /** @Computed: a getter cached for the rest of the request, never part of the component's state. */
 declare function Computed<T>(getter: (this: object) => T, context: ClassGetterDecoratorContext): (this: object) => T;
 
+/**
+ * Runs Live.test()'s mount and each update. The testing package binds one for every test, so they run in a request
+ * scope like the test's HTTP requests (a request, the carried session, actingAs users) and what they change carries
+ * on to the next request. Without one they run in the current scope.
+ */
+type TestRequestScope = <T>(run: () => Promise<T>) => Promise<T>;
+declare const TestRequestScope: Token<TestRequestScope>;
 /**
  * Livewire's Livewire::test(): drives one component through the real mount → snapshot → checksum → update pipeline
- * (no HTTP). Actions are async (`await counter.call('increment')`); assertions are sync and return `this`.
+ * (no HTTP), inside the test's request scope. Actions are async (`await counter.call('increment')`); assertions are
+ * sync and return `this`.
  */
 declare class Testable<C extends Component = Component> {
     #private;
     private readonly manager;
+    private readonly scope;
     private constructor();
     /** Mounts `component` with `params`, as `<Live component={…} {...params} />` would. */
     static create<C extends Component>(component: Class<C> | string, params?: Record<string, unknown>): Promise<Testable<C>>;
@@ -1988,8 +2113,14 @@ declare class LiveComponentManager implements LiveManager {
     /** 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 route action of POST /oriel/live/update. */
-    handle(request: HttpRequest): Promise<LiveUpdateResponse>;
+    /**
+     * 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
+     * bound again. A signed-out tab gets a 401, a revoked ability a 403 and a deleted model a 404, before the component
+     * hydrates. When a middleware answers instead (a redirect), that is the response. A key first flashed during the
+     * update shows in this response only, unless the update redirects.
+     */
+    handle(request: HttpRequest): Promise<LiveUpdateResponse | Response>;
     /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
     page(component: Component): Promise<unknown>;
     /** Parses and checks a snapshot: a bad checksum throws before anything is hydrated. */
@@ -2002,8 +2133,14 @@ declare class LiveComponentManager implements LiveManager {
     private applyUpdate;
     /** Runs one call from the browser: a magic action, an event, 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. */
+    /**
+     * Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. A
+     * WithPagination component's page and page URL are what paginate() reads while it renders, as in its mount() and in
+     * its update's hooks and actions.
+     */
     private render;
+    /** The absolute URL of the page a memo path belongs to, on the current request's origin ('/' + path without one). */
+    private pageUrl;
     /** Dispatches, redirects: the effects every response carries. */
     private effects;
     /** dehydrate() hook, then the state as snapshot data, the error bag, and the checksum over both. */
@@ -2013,8 +2150,9 @@ declare class LiveComponentManager implements LiveManager {
 /** The URI the client runtime posts updates to. */
 declare const UPDATE_URI = "/oriel/live/update";
 /**
- * Binds the LiveManager, 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.
+ * 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.
  */
 declare class LiveServiceProvider extends ServiceProvider {
     register(): void;
@@ -2065,4 +2203,65 @@ declare class InvalidLiveRequestError extends LiveError {
     readonly status: number;
 }
 
-export { type ResponseContext as $, AnonymousNotifiable as A, BusFake as B, Component as C, DatabaseMigrations as D, EventFake as E, FakeDisk as F, InteractsWithConsole as G, HttpClient as H, InvalidLiveRequestError as I, InteractsWithDatabase as J, type JsonStructure as K, Live as L, MailFake as M, NotificationFake as N, On as O, PendingEvent as P, QueueFake as Q, MailRecord as R, MakesHttpRequests as S, type Target as T, UPDATE_URI as U, PendingCommand as V, type PushedJob as W, RefreshDatabase as X, RefreshDatabaseState as Y, type RequestData as Z, type RequestOptions as _, type ComponentResult as a, type ResponseCookie as a0, type SentNotification as a1, StorageFake as a2, TESTING_ENVIRONMENT as a3, type TableOrModel as a4, TestCase as a5, type TestHooks as a6, TestResponse as a7, type TestTrait as a8, actingAsAuthFactory as a9, addresses as aa, applyEnvironment as ab, cookieHeader as ac, cookiePrefix as ad, decryptCookie as ae, encryptCookie as af, flatten as ag, guessMimeType as ah, inertiaPageOf as ai, install as aj, isExpired as ak, matches as al, nameOf as am, recordingExceptionHandler as an, recordingViewFactory as ao, responseCookies as ap, runCommand as aq, usingInMemoryDatabase as ar, 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, PropertyNotUpdatableError as l, Testable as m, componentName as n, live as o, AssertableInertia as p, AssertableJson as q, type BatchRecord as r, type BootOptions as s, type CountOrFilter as t, type DatabaseTestOptions as u, DatabaseTransactions as v, type DispatchedEvent as w, type ExpectedErrors as x, FakeFile as y, InteractsWithApplication as z };
+/** The route middleware an update re-applies by default (config live.persistent_middleware), by alias. */
+declare const PERSISTENT_MIDDLEWARE: string[];
+/** A route middleware after alias and group expansion: 'auth:web' → { cls: Authenticate, parameters: ['web'] }. */
+interface PersistentMiddleware {
+    readonly cls: MiddlewareClass;
+    readonly parameters: readonly string[];
+}
+/**
+ * Livewire's persistent middleware: the middleware among `persistent` (aliases) that the page route (the component's
+ * memo path and method) ran, in the order an update runs them. A path no route matches has none.
+ */
+declare function persistentMiddleware(router: Router, persistent: readonly string[], method: string, path: string): PersistentMiddleware[];
+
+type ComponentConstructor = abstract new (...args: any[]) => Component;
+/** What WithPagination() adds to a component: its page and the actions that move it. */
+interface Paginated {
+    /** The current page. The browser may set it; Live reads it as a page number. */
+    page: number;
+    nextPage(): Promise<void>;
+    previousPage(): Promise<void>;
+    gotoPage(page: number | string): Promise<void>;
+    resetPage(): Promise<void>;
+    setPage(page: number | string): Promise<void>;
+}
+/**
+ * Livewire's WithPagination: `class Posts extends WithPagination(Component)`. The public `page` (1 to start; there
+ * is no address-bar sync) is what `paginate()` shows in the component (in `render()`, `mount()`, `hydrate()`, the
+ * update hooks and actions, or in a `@Computed` getter any of them reads), and its page links are built on the
+ * page's URL. The actions move it: `o:click="nextPage"`, `previousPage`, `gotoPage(3)`, `setPage(3)`,
+ * `resetPage` (call it from `updatedSearch()` so a new search starts on page 1). `updatingPage(page)` and
+ * `updatedPage(page)` run around every change. One paginator per component: other page names read the request.
+ */
+declare function WithPagination<TBase extends ComponentConstructor>(Base: TBase): TBase & (abstract new (...args: any[]) => Paginated);
+
+/**
+ * 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).
+ */
+interface PaginationSource {
+    currentPage(): number;
+    lastPage?(): number;
+    hasMorePages(): boolean;
+    onFirstPage(): boolean;
+    /** Page buttons on each side of the current one (the paginator's onEachSide(), 3 by default). */
+    readonly onEachSideCount?: number;
+    /** Not cursorPaginate(): its pages are cursors, which a component's page number can't follow. */
+    readonly nextCursor?: never;
+}
+interface PaginationProps {
+    paginator: PaginationSource;
+    /** Classes for the <nav>, such as its layout ("flex gap-2"); in your file, so Tailwind generates them. */
+    class?: string;
+}
+/**
+ * Livewire's pagination links for a WithPagination component: `<Pagination paginator={posts} />` in render(). A
+ * <nav aria-label="Pagination"> with « Previous, the page buttons and Next » as Live actions (previousPage,
+ * gotoPage(n), nextPage), the current page marked aria-current="page", the ends disabled, the kits' theme classes
+ * (btn, btn-secondary). Nothing when everything fits on one page. The address bar is left alone.
+ */
+declare function Pagination({ paginator, class: className }: PaginationProps): Htmlable;
+
+export { type JsonStructure as $, AnonymousNotifiable as A, BusFake as B, Component as C, type BootOptions as D, EventFake as E, FakeDisk as F, type CountOrFilter as G, DatabaseMigrations as H, InvalidLiveRequestError as I, type DatabaseTestOptions as J, DatabaseTransactions as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, type DispatchedEvent as R, type ExpectedErrors as S, type Target as T, UPDATE_URI as U, FakeFile as V, WithPagination as W, HttpClient as X, InteractsWithApplication as Y, InteractsWithConsole as Z, InteractsWithDatabase as _, type ComponentResult as a, MailRecord as a0, MakesHttpRequests as a1, PendingCommand as a2, type PushedJob as a3, RefreshDatabase as a4, RefreshDatabaseState as a5, type RequestData as a6, type RequestOptions as a7, type ResponseContext as a8, type ResponseCookie as a9, usingInMemoryDatabase as aA, type SentNotification as aa, StorageFake as ab, TESTING_ENVIRONMENT as ac, type TableOrModel as ad, TestCase as ae, type TestHooks as af, TestResponse as ag, type TestTrait as ah, actingAsAuthFactory as ai, addresses as aj, applyEnvironment as ak, cookieHeader as al, cookiePrefix as am, decryptCookie as an, encryptCookie as ao, flatten as ap, guessMimeType as aq, inertiaPageOf as ar, install as as, isExpired as at, matches as au, nameOf as av, recordingExceptionHandler as aw, recordingViewFactory as ax, responseCookies as ay, runCommand 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, TestRequestScope as s, Testable as t, componentName as u, live as v, persistentMiddleware as w, AssertableInertia as x, AssertableJson as y, type BatchRecord as z };

package/dist/testing.d.ts

@@ -1,3 +1,3 @@
-export { A as AnonymousNotifiable, p as AssertableInertia, q as AssertableJson, r as BatchRecord, s as BootOptions, B as BusFake, t as CountOrFilter, D as DatabaseMigrations, u as DatabaseTestOptions, v as DatabaseTransactions, w as DispatchedEvent, E as EventFake, x as ExpectedErrors, F as FakeDisk, y as FakeFile, H as HttpClient, z as InteractsWithApplication, G as InteractsWithConsole, J as InteractsWithDatabase, K as JsonStructure, L as Live, M as MailFake, R as MailRecord, S as MakesHttpRequests, N as NotificationFake, V as PendingCommand, W as PushedJob, Q as QueueFake, X as RefreshDatabase, Y as RefreshDatabaseState, Z as RequestData, _ as RequestOptions, $ as ResponseContext, a0 as ResponseCookie, a1 as SentNotification, a2 as StorageFake, a3 as TESTING_ENVIRONMENT, a4 as TableOrModel, T as Target, a5 as TestCase, a6 as TestHooks, a7 as TestResponse, a8 as TestTrait, m as Testable, a9 as actingAsAuthFactory, aa as addresses, ab as applyEnvironment, ac as cookieHeader, ad as cookiePrefix, ae as decryptCookie, af as encryptCookie, ag as flatten, ah as guessMimeType, ai as inertiaPageOf, aj as install, ak as isExpired, al as matches, am as nameOf, an as recordingExceptionHandler, ao as recordingViewFactory, ap as responseCookies, aq as runCommand, ar as usingInMemoryDatabase } from './testing--F6FODc_.js';
+export { A as AnonymousNotifiable, x as AssertableInertia, y as AssertableJson, z as BatchRecord, D as BootOptions, B as BusFake, G as CountOrFilter, H as DatabaseMigrations, J as DatabaseTestOptions, K as DatabaseTransactions, R as DispatchedEvent, E as EventFake, S as ExpectedErrors, F as FakeDisk, V as FakeFile, X as HttpClient, Y as InteractsWithApplication, Z as InteractsWithConsole, _ as InteractsWithDatabase, $ as JsonStructure, L as Live, M as MailFake, a0 as MailRecord, a1 as MakesHttpRequests, N as NotificationFake, a2 as PendingCommand, a3 as PushedJob, Q as QueueFake, a4 as RefreshDatabase, a5 as RefreshDatabaseState, a6 as RequestData, a7 as RequestOptions, a8 as ResponseContext, a9 as ResponseCookie, aa as SentNotification, ab as StorageFake, ac as TESTING_ENVIRONMENT, ad as TableOrModel, T as Target, ae as TestCase, af as TestHooks, ag as TestResponse, ah as TestTrait, t as Testable, ai as actingAsAuthFactory, aj as addresses, ak as applyEnvironment, al as cookieHeader, am as cookiePrefix, an as decryptCookie, ao as encryptCookie, ap as flatten, aq as guessMimeType, ar as inertiaPageOf, as as install, at as isExpired, au as matches, av as nameOf, aw as recordingExceptionHandler, ax as recordingViewFactory, ay as responseCookies, az as runCommand, aA as usingInMemoryDatabase } from './testing-BErengYY.js';
 import './contracts.js';
 import './index.d-DOlTeG-8.js';

package/dist/testing.js

@@ -45,9 +45,9 @@ import {
   responseCookies,
   runCommand,
   usingInMemoryDatabase
-} from "./chunk-I2OMKIQZ.js";
-import "./chunk-HU43NADT.js";
-import "./chunk-S7YC43IH.js";
+} from "./chunk-WNJP46B7.js";
+import "./chunk-PM5YTG57.js";
+import "./chunk-BSQKOLSK.js";
 export {
   AnonymousNotifiable,
   AssertableInertia,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orieljs/framework",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.5",
   "description": "Oriel: a Laravel-style, full-stack TypeScript framework for Node.js and Bun.",
   "type": "module",
   "license": "Apache-2.0",
@@ -56,35 +56,35 @@
     "pluralize": "8.0.0"
   },
   "devDependencies": {
-    "@orieljs/auth": "0.1.0-alpha.3",
-    "@orieljs/bus": "0.1.0-alpha.3",
-    "@orieljs/collections": "0.1.0-alpha.3",
-    "@orieljs/cache": "0.1.0-alpha.3",
-    "@orieljs/config": "0.1.0-alpha.3",
-    "@orieljs/console": "0.1.0-alpha.3",
-    "@orieljs/container": "0.1.0-alpha.3",
-    "@orieljs/cookie": "0.1.0-alpha.3",
-    "@orieljs/contracts": "0.1.0-alpha.3",
-    "@orieljs/database": "0.1.0-alpha.3",
-    "@orieljs/encryption": "0.1.0-alpha.3",
-    "@orieljs/events": "0.1.0-alpha.3",
-    "@orieljs/filesystem": "0.1.0-alpha.3",
-    "@orieljs/hashing": "0.1.0-alpha.3",
-    "@orieljs/foundation": "0.1.0-alpha.3",
-    "@orieljs/http": "0.1.0-alpha.3",
-    "@orieljs/inertia": "0.1.0-alpha.3",
-    "@orieljs/live": "0.1.0-alpha.3",
-    "@orieljs/log": "0.1.0-alpha.3",
-    "@orieljs/mail": "0.1.0-alpha.3",
-    "@orieljs/pipeline": "0.1.0-alpha.3",
-    "@orieljs/notifications": "0.1.0-alpha.3",
-    "@orieljs/routing": "0.1.0-alpha.3",
-    "@orieljs/queue": "0.1.0-alpha.3",
-    "@orieljs/session": "0.1.0-alpha.3",
-    "@orieljs/support": "0.1.0-alpha.3",
-    "@orieljs/testing": "0.1.0-alpha.3",
-    "@orieljs/view": "0.1.0-alpha.3",
-    "@orieljs/validation": "0.1.0-alpha.3"
+    "@orieljs/bus": "0.1.0-alpha.5",
+    "@orieljs/auth": "0.1.0-alpha.5",
+    "@orieljs/cache": "0.1.0-alpha.5",
+    "@orieljs/config": "0.1.0-alpha.5",
+    "@orieljs/collections": "0.1.0-alpha.5",
+    "@orieljs/console": "0.1.0-alpha.5",
+    "@orieljs/container": "0.1.0-alpha.5",
+    "@orieljs/contracts": "0.1.0-alpha.5",
+    "@orieljs/cookie": "0.1.0-alpha.5",
+    "@orieljs/encryption": "0.1.0-alpha.5",
+    "@orieljs/events": "0.1.0-alpha.5",
+    "@orieljs/foundation": "0.1.0-alpha.5",
+    "@orieljs/database": "0.1.0-alpha.5",
+    "@orieljs/hashing": "0.1.0-alpha.5",
+    "@orieljs/filesystem": "0.1.0-alpha.5",
+    "@orieljs/http": "0.1.0-alpha.5",
+    "@orieljs/inertia": "0.1.0-alpha.5",
+    "@orieljs/log": "0.1.0-alpha.5",
+    "@orieljs/notifications": "0.1.0-alpha.5",
+    "@orieljs/pipeline": "0.1.0-alpha.5",
+    "@orieljs/live": "0.1.0-alpha.5",
+    "@orieljs/queue": "0.1.0-alpha.5",
+    "@orieljs/routing": "0.1.0-alpha.5",
+    "@orieljs/session": "0.1.0-alpha.5",
+    "@orieljs/mail": "0.1.0-alpha.5",
+    "@orieljs/support": "0.1.0-alpha.5",
+    "@orieljs/testing": "0.1.0-alpha.5",
+    "@orieljs/validation": "0.1.0-alpha.5",
+    "@orieljs/view": "0.1.0-alpha.5"
   },
   "peerDependencies": {
     "pg": "^8.23.0",