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

package/dist/contracts.d.ts

@@ -334,7 +334,11 @@ type ActionMethods<C> = {
 }[keyof C] & string;
 type ControllerAction<C> = readonly [Class<C>, ActionMethods<C>];
 type RouteClosure = (...args: any[]) => unknown;
-type RouteAction = RouteClosure | ControllerAction<any>;
+/** 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[];
@@ -369,16 +373,18 @@ interface CurrentRoute {
 }
 declare const CurrentRoute: Token<CurrentRoute>;
 interface Router {
-    get<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
-    post<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
-    put<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
-    patch<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
-    delete<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
-    options<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
-    any<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
-    match<C>(methods: string[], uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    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;
@@ -414,6 +420,15 @@ interface RouteModelResolver {
     resolveExplicit(model: Class<unknown>, value: string, field?: string): Promise<unknown>;
 }
 declare const RouteModelResolver: Token<RouteModelResolver>;
+/**
+ * Route name → parameters, for the typed route() and redirect().route() helpers. Empty until `oriel route:types`
+ * augments it (types/routes.d.ts); while it is empty any string is accepted. The contracts themselves keep taking
+ * strings: the framework builds route names at run time.
+ */
+interface RouteList {
+}
+/** A route name: the generated ones, or any string before `oriel route:types` has run. */
+type RouteName = [keyof RouteList] extends [never] ? string : Extract<keyof RouteList, string>;
 interface UrlGenerator {
     to(path: string, query?: Record<string, unknown>, absolute?: boolean): string;
     route(name: string, parameters?: unknown, absolute?: boolean): string;
@@ -492,6 +507,8 @@ interface ViewFactory {
     exists(name: string): boolean;
     share(key: string | Record<string, unknown>, value?: unknown): void;
     composer(views: string | string[], composer: (view: View) => void | Promise<void>): void;
+    /** Renders TSX (an element, a string, an Htmlable, a View, promises of them) to HTML, like Blade::render(). */
+    renderToString(node: unknown): Promise<string>;
 }
 declare const ViewFactory: Token<ViewFactory>;
 
@@ -1124,38 +1141,99 @@ interface FilesystemManager extends Filesystem {
 }
 declare const FilesystemManager: Token<FilesystemManager>;
 
-/** The Inertia page object (protocol v2). */
+/** Infinite-scroll metadata for one prop (page.scrollProps[path]). */
+interface InertiaScrollProp {
+    pageName: string;
+    previousPage: string | number | null;
+    nextPage: string | number | null;
+    currentPage: string | number | null;
+    reset: boolean;
+}
+/** A once prop the client keeps between visits (page.onceProps[key]). `expiresAt` is epoch milliseconds. */
+interface InertiaOnceProp {
+    prop: string;
+    expiresAt: number | null;
+}
+/**
+ * The Inertia page object (protocol v3, @inertiajs/core 3.x). Only component, props, url and version are always
+ * present; the other fields are left out when empty or false.
+ */
 interface InertiaPage {
     component: string;
     props: Record<string, unknown>;
+    /** Path and query, never absolute: '/posts?page=2'. */
     url: string;
-    version: string | null;
-    encryptHistory?: boolean;
-    clearHistory?: boolean;
+    /** '' when the app has no asset version. */
+    version: string;
+    sharedProps?: string[];
     mergeProps?: string[];
+    prependProps?: string[];
+    deepMergeProps?: string[];
+    /** '<prop path>.<key field>', e.g. 'posts.data.id'. */
+    matchPropsOn?: string[];
+    /** Group name → prop paths loaded after the first render. */
     deferredProps?: Record<string, string[]>;
+    rescuedProps?: string[];
+    scrollProps?: Record<string, InertiaScrollProp>;
+    onceProps?: Record<string, InertiaOnceProp>;
+    clearHistory?: true;
+    encryptHistory?: true;
+    flash?: Record<string, unknown>;
+    preserveFragment?: true;
 }
 interface InertiaResponse extends Responsable {
     with(key: string | Record<string, unknown>, value?: unknown): this;
     withViewData(key: string | Record<string, unknown>, value?: unknown): this;
+    rootView(view: string): this;
+    /** Flash data for the next page (page.flash), stored in the session. */
+    flash(key: string | Record<string, unknown>, value?: unknown): this;
 }
 type PropCallback<T = unknown> = () => T | Promise<T>;
+/** The SSR result spliced into the root view: the `head` tags and the rendered `body`. */
+interface InertiaSsrResponse {
+    head: string;
+    body: string;
+}
+/** Sends a page to the SSR server. Resolves to undefined when SSR is off, unreachable or failing. */
+interface InertiaSsrGateway {
+    dispatch(page: InertiaPage): Promise<InertiaSsrResponse | undefined>;
+}
+declare const InertiaSsrGateway: Token<InertiaSsrGateway>;
 interface InertiaFactory {
     render(component: string, props?: Record<string, unknown>): InertiaResponse;
     share(key: string | Record<string, unknown>, value?: unknown): void;
+    /** A shared once prop: sent on the first visit, then kept by the client. */
+    shareOnce(key: string, callback: PropCallback): void;
     getShared(key?: string): unknown;
-    version(version: string | (() => string | Promise<string>)): void;
+    flushShared(): void;
+    version(version: string | null | (() => string | null | Promise<string | null>)): void;
+    getVersion(): Promise<string>;
+    setRootView(view: string): void;
     /** Only evaluated on partial reloads that ask for it. */
     optional<T>(callback: PropCallback<T>): unknown;
     /** Loaded in a follow-up request after the first render. */
     defer<T>(callback: PropCallback<T>, group?: string): unknown;
     /** Always included, even in partial reloads. */
     always<T>(value: T | PropCallback<T>): unknown;
-    /** Merged with the existing client-side value instead of replacing it. */
+    /** Appended to the existing client-side value instead of replacing it. */
     merge<T>(value: T | PropCallback<T>): unknown;
-    /** 409 + X-Inertia-Location for external redirects. */
+    /** Deep-merged with the existing client-side value. */
+    deepMerge<T>(value: T | PropCallback<T>): unknown;
+    /** Resolved once, then remembered by the client. */
+    once<T>(callback: PropCallback<T>): unknown;
+    /** Infinite scroll over a paginator: merged page by page, with scroll metadata. */
+    scroll<T>(value: T | PropCallback<T>, wrapper?: string): unknown;
+    /** Flash data for the next page (page.flash), stored in the session. */
+    flash(key: string | Record<string, unknown>, value?: unknown): this;
+    encryptHistory(encrypt?: boolean): void;
+    /** The next page tells the client to clear its encrypted history. */
+    clearHistory(): void;
+    /** The next page keeps the URL fragment of the request that redirected to it. */
+    preserveFragment(): void;
+    /** 409 + X-Inertia-Location for Inertia requests, a plain 302 otherwise. */
     location(url: string): Response;
-    setRootView(view: string): void;
+    /** Redirect back (Inertia.flash('saved', true).back()). */
+    back(fallback?: string, status?: number): RedirectResponse;
 }
 declare const InertiaFactory: Token<InertiaFactory>;
 
@@ -1175,11 +1253,18 @@ interface LiveSnapshot {
 }
 interface LiveEffects {
     html?: string;
+    /** Browser events from this.dispatch(); `self` keeps one on this component, `to` sends it to one component name. */
     dispatches?: Array<{
         name: string;
-        params: unknown[];
+        params: Record<string, unknown>;
+        self?: true;
+        to?: string;
     }>;
+    /** Events this component listens to (@On, static listeners); sent with the first render. */
+    listeners?: string[];
     redirect?: string;
+    /** Follow `redirect` with o:navigate instead of a full page load. */
+    redirectUsingNavigate?: true;
     returns?: unknown[];
 }
 interface LiveUpdateRequest {
@@ -1201,12 +1286,17 @@ interface LiveUpdateResponse {
 }
 interface LiveManager {
     register(component: Class<unknown>, name?: string): void;
-    /** Server-renders the first HTML (snapshot embedded). */
-    mount(component: string | Class<unknown>, params?: Record<string, unknown>): Promise<string>;
+    /** Server-renders the first HTML (snapshot embedded). `key` identifies a child inside its parent (o:key). */
+    mount(component: string | Class<unknown>, params?: Record<string, unknown>, key?: string): Promise<string>;
     /** Checks checksums and CSRF, then applies updates and calls, re-renders and returns new snapshots. */
     update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
+    /**
+     * A full-page component (Route.get('/counter', Counter)): mounts `component` (a component instance) with the current route's parameters and
+     * returns the response, its layout view or a redirect.
+     */
+    page(component: object): Promise<unknown>;
     isLiveRequest(request: HttpRequest): boolean;
 }
 declare const LiveManager: Token<LiveManager>;
 
-export { type AbilityCallback, type Abstract, type ActionMethods, type Address, Application, type Arrayable, type Attachment, AuthFactory, type Authenticatable, type AuthenticationError, type Batch, BatchRepository, type BodyInit, BusDispatcher, CacheManager, type CacheRepository, type Class, ClassRegistry, type ClosureCommand, type Command, type CommandContext, type Concrete, type ConfigCallbacks, ConfigRepository, ConsoleKernel, Container, type Content, type ControllerAction, type Cookie, CookieJar, type Credentials, CurrentRoute, type DatabaseConnection, DatabaseManager, type DriverName, Encrypter, type Enumerable, type Envelope, type ErrorKind, EventDispatcher, ExceptionCallbacks, ExceptionHandler, type ExceptionsConfigurator, type Factory, type FailedJob, FailedJobProvider, type Filesystem, FilesystemManager, Gate, type Guard, Hasher, type HeadersInit, type Htmlable, HttpKernel, HttpRequest, InertiaFactory, type InertiaPage, type InertiaResponse, type Job, type Jsonable, type Listener, type ListenerClass, type LiveEffects, LiveManager, type LiveSnapshot, type LiveUpdateRequest, type LiveUpdateResponse, type Lock, type LogLevel, LogManager, type Logger, MailManager, type MailRecipient, type MailTransport, type Mailable, type Mailer, type MessageBag, type Middleware, MiddlewareCallbacks, type MiddlewareClass, type MiddlewareConfigurator, type MiddlewareReference, type ModelInstance, type ModelNotFoundError, type ModelStatic, type MustVerifyEmail, type Next, type Notifiable, type Notification, type NotificationChannel, NotificationDispatcher, type Operator, type OptionValue, type OrielError, type OutgoingMessage, PasswordBroker, type PasswordStatus, type PendingBatch, type PendingBatchOptions, type PendingChain, type PendingMail, type Pipe, type PipeClosure, type PipeNext, type Pipeline, PipelineFactory, type PropCallback, type PutOptions, type QueryBuilder, type Queue, type QueueJob, QueueManager, type QueuePayload, type RedirectResponse, Redirector, type ResourceOptions, type Responsable, ResponseFactory, type Route, type RouteAction, type RouteClosure, RouteModelResolver, type RouteRegistrar, Router, RoutingPaths, type Row, type RuleCallback, type Rules, Schedule, type ScheduledEvent, type SentMessage, type ServiceProvider, type ServiceProviderClass, Session, type SessionHandler, type ShouldQueue, type StatefulGuard, type Token, type UploadedFile, UrlGenerator, type UserProvider, type ValidationError, ValidationFactory, type ValidationRule, type Validator, type View, ViewFactory, token };
+export { type AbilityCallback, type Abstract, type ActionMethods, type Address, Application, type Arrayable, type Attachment, AuthFactory, type Authenticatable, type AuthenticationError, type Batch, BatchRepository, type BodyInit, BusDispatcher, CacheManager, type CacheRepository, type Class, ClassRegistry, type ClosureCommand, type Command, type CommandContext, type Concrete, type ConfigCallbacks, ConfigRepository, ConsoleKernel, Container, type Content, type ControllerAction, type Cookie, CookieJar, type Credentials, CurrentRoute, type DatabaseConnection, DatabaseManager, type DriverName, Encrypter, type Enumerable, type Envelope, type ErrorKind, EventDispatcher, ExceptionCallbacks, ExceptionHandler, type ExceptionsConfigurator, type Factory, type FailedJob, FailedJobProvider, type Filesystem, FilesystemManager, Gate, type Guard, Hasher, type HeadersInit, type Htmlable, HttpKernel, HttpRequest, InertiaFactory, type InertiaOnceProp, type InertiaPage, type InertiaResponse, type InertiaScrollProp, InertiaSsrGateway, type InertiaSsrResponse, type InvokableClass, type Job, type Jsonable, type Listener, type ListenerClass, type LiveEffects, LiveManager, type LiveSnapshot, type LiveUpdateRequest, type LiveUpdateResponse, type Lock, type LogLevel, LogManager, type Logger, MailManager, type MailRecipient, type MailTransport, type Mailable, type Mailer, type MessageBag, type Middleware, MiddlewareCallbacks, type MiddlewareClass, type MiddlewareConfigurator, type MiddlewareReference, type ModelInstance, type ModelNotFoundError, type ModelStatic, type MustVerifyEmail, type Next, type Notifiable, type Notification, type NotificationChannel, NotificationDispatcher, type Operator, type OptionValue, type OrielError, type OutgoingMessage, PasswordBroker, type PasswordStatus, type PendingBatch, type PendingBatchOptions, type PendingChain, type PendingMail, type Pipe, type PipeClosure, type PipeNext, type Pipeline, PipelineFactory, type PropCallback, type PutOptions, type QueryBuilder, type Queue, type QueueJob, QueueManager, type QueuePayload, type RedirectResponse, Redirector, type ResourceOptions, type Responsable, ResponseFactory, type Route, type RouteAction, type RouteClosure, type RouteList, RouteModelResolver, type RouteName, type RouteRegistrar, Router, RoutingPaths, type Row, type RuleCallback, type Rules, Schedule, type ScheduledEvent, type SentMessage, type ServiceProvider, type ServiceProviderClass, Session, type SessionHandler, type ShouldQueue, type StatefulGuard, type Token, type UploadedFile, UrlGenerator, type UserProvider, type ValidationError, ValidationFactory, type ValidationRule, type Validator, type View, ViewFactory, token };

package/dist/contracts.js

@@ -22,6 +22,7 @@ import {
   HttpKernel,
   HttpRequest,
   InertiaFactory,
+  InertiaSsrGateway,
   LiveManager,
   LogManager,
   MailManager,
@@ -41,7 +42,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-K6MAA3RM.js";
+} from "./chunk-S7YC43IH.js";
 export {
   Application,
   AuthFactory,
@@ -66,6 +67,7 @@ export {
   HttpKernel,
   HttpRequest,
   InertiaFactory,
+  InertiaSsrGateway,
   LiveManager,
   LogManager,
   MailManager,

package/dist/index.d-DOlTeG-8.d.ts

@@ -0,0 +1,99 @@
+import { Token as Token$1 } from './contracts.js';
+
+/** A typed, runtime-unique key for container bindings. */
+interface Token<T> {
+    readonly id: symbol;
+    readonly description: string;
+    /** Phantom field: only carries T at the type level. Never set at runtime. */
+    readonly __type?: T;
+}
+type Class<T> = abstract new (...args: any[]) => T;
+type Abstract<T> = Token<T> | Class<T>;
+type Factory<T> = (container: Container) => T;
+type Concrete<T> = Factory<T> | (new () => T);
+interface Container {
+    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
+    bind<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
+    singleton<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
+    scoped<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
+    instance<T>(abstract: Abstract<T>, instance: T): T;
+    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
+    make<T>(abstract: Abstract<T>): T;
+    bound(abstract: Abstract<unknown>): boolean;
+    resolved(abstract: Abstract<unknown>): boolean;
+    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
+    extend<T>(abstract: Abstract<T>, extender: (instance: T, container: Container) => T): void;
+    /** Called after each resolution of the abstract. Root only; throws on a scope. */
+    resolving<T>(abstract: Abstract<T>, callback: (instance: T, container: Container) => void): void;
+    forgetInstance(abstract: Abstract<unknown>): void;
+    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
+    createScope(): Container;
+    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
+    run<R>(fn: () => R): R;
+}
+declare const Container: Token<Container>;
+
+interface ServiceProvider {
+    /** 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;
+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 | ServiceProviderClass): Promise<ServiceProvider>;
+    getProviders(): ServiceProvider[];
+    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$1<Application>;
+
+interface ConfigRepository {
+    has(key: string): boolean;
+    /** Dot notation: get('database.connections.sqlite.database'). */
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    set(key: string, value: unknown): void;
+    set(values: Record<string, unknown>): void;
+    push(key: string, value: unknown): void;
+    all(): Record<string, unknown>;
+}
+declare const ConfigRepository: Token$1<ConfigRepository>;
+interface ClassRegistry {
+    /** Registers under `name` (default: cls.name). Throws if the name is already taken by a different class. */
+    register(cls: Class<unknown>, name?: string): string;
+    nameOf(cls: Class<unknown>): string | undefined;
+    resolve<T = unknown>(name: string): Class<T>;
+    has(name: string): boolean;
+}
+declare const ClassRegistry: Token$1<ClassRegistry>;
+
+export { Application as A, ClassRegistry as C, type ServiceProvider as S, type Class as a, type Abstract as b, ConfigRepository as c };