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

package/dist/jsx-runtime-B8J6xq-7.d.ts

@@ -0,0 +1,350 @@
+/** A typed, runtime-unique key for container bindings. */
+interface Token$1<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$1<T> | Class<T>;
+type Factory$1<T> = (container: Container) => T;
+type Concrete<T> = Factory$1<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$1<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$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>;
+
+/** 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;
+}
+interface Htmlable {
+    toHtml(): string;
+}
+
+interface View$1 extends Htmlable {
+    readonly name: string;
+    with(key: string | Record<string, unknown>, value?: unknown): this;
+    render(): Promise<string>;
+}
+/** Resolves 'posts.index' → resources/views/posts/index.tsx and renders it to HTML on the server. */
+interface ViewFactory {
+    make(name: string, data?: Record<string, unknown>): View$1;
+    exists(name: string): boolean;
+    share(key: string | Record<string, unknown>, value?: unknown): void;
+    composer(views: string | string[], composer: (view: View$1) => void | Promise<void>): void;
+}
+declare const ViewFactory: Token<ViewFactory>;
+
+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`. */
+interface OrielError extends Error {
+    readonly kind: ErrorKind;
+    /** HTTP status the error should render as, when relevant. */
+    readonly status?: number;
+    readonly headers?: Record<string, string>;
+}
+
+declare abstract class ServiceProvider implements ServiceProvider$1 {
+    protected readonly app: Application;
+    constructor(app: Application);
+    register(): void;
+    boot(): void | Promise<void>;
+    /** Package defaults under `key`; values the app already set win (shallow merge, like Laravel). */
+    protected mergeConfigFrom(defaults: Record<string, unknown>, key: string): void;
+}
+
+interface FacadeStatics<T> {
+    getFacadeRoot(): T;
+    /** Replace the instance in the current container (used by X.fake()). */
+    swap(instance: T): void;
+}
+type Facade<T, X = object> = T & X & FacadeStatics<T>;
+
+/** Marks the objects jsx() returns (Symbol.for, so two copies of the package agree). */
+declare const ELEMENT: unique symbol;
+type Props = Record<string, unknown>;
+/** Anything that can appear as a child: text is escaped, Htmlable is emitted as-is, promises are awaited. */
+type Renderable = OrielElement | string | number | bigint | boolean | null | undefined | Htmlable | Promise<Renderable> | Iterable<Renderable>;
+/** A function component. It may be async: the renderer awaits it. */
+type Component<P = Props> = (props: P) => Renderable | Promise<Renderable>;
+/**
+ * `<>…</>` and `<Fragment>`: renders its children only. A symbol at runtime; typed as a component so that
+ * `<Fragment>` type-checks as a JSX tag.
+ */
+declare const Fragment: (props: {
+    children?: Renderable;
+}) => Renderable;
+type ElementType = string | Component<never>;
+/** What `<div />` evaluates to: an inert description, rendered later by renderToString()/renderToStream(). */
+interface OrielElement {
+    readonly [ELEMENT]: true;
+    readonly type: ElementType;
+    readonly props: Props;
+    readonly key: string | number | undefined;
+}
+declare function createElement(type: ElementType, props: Props | null | undefined, key?: string | number): OrielElement;
+declare function isElement(value: unknown): value is OrielElement;
+
+/** Markup that must not be escaped again (Laravel's Illuminate\Support\HtmlString). */
+declare class HtmlString implements Htmlable {
+    private readonly html;
+    constructor(html?: string);
+    toHtml(): string;
+    toString(): string;
+    isEmpty(): boolean;
+}
+/** Marks trusted markup so the renderer emits it unescaped: {raw(markdownHtml)}. Never pass user input. */
+declare function raw(html: string): HtmlString;
+declare function isHtmlable(value: unknown): value is Htmlable;
+/** Laravel's e(): htmlspecialchars(ENT_QUOTES, double-encode). Htmlable values pass through; null is ''. */
+declare function e(value: unknown): string;
+
+type ClassValue = string | number | null | undefined | false | ClassValue[] | Record<string, unknown>;
+type StyleObject = Record<string, string | number | null | undefined | false>;
+/** `class` accepts strings, arrays and `{ name: condition }` objects, like Blade's @class. */
+declare function classNames(value: ClassValue): string;
+/** `{ marginTop: 4, '--gap': '1rem' }` → `margin-top:4px;--gap:1rem`. */
+declare function styleString(style: StyleObject): string;
+
+/** Renders JSX (or any Renderable) to an HTML string. Async components and promises are awaited in order. */
+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 automatic JSX runtime (`jsxImportSource: "@orieljs/view"`). jsx() only describes elements; rendering
+ * (escaping, async components) happens in renderToString()/renderToStream().
+ */
+
+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 {
+    children?: Renderable;
+    class?: ClassValue;
+    className?: ClassValue;
+    style?: string | StyleObject;
+    dangerouslySetInnerHTML?: {
+        __html: string;
+    };
+    [attribute: string]: unknown;
+}
+declare namespace JSX {
+    type Element = OrielElement;
+    /** Lets components be async: `async function Posts() { … }` is a valid element type. */
+    type ElementType = string | Component<never>;
+    interface ElementChildrenAttribute {
+        children: unknown;
+    }
+    interface IntrinsicAttributes {
+        key?: string | number;
+    }
+    interface IntrinsicElements {
+        [element: string]: HtmlAttributes;
+    }
+}
+
+/**
+ * Programmer errors (Laravel throws InvalidArgumentException for these). Not an HTTP condition, so kind 'Server':
+ * the exception handler reports them and renders a 500 whose message is hidden unless app.debug is on.
+ */
+declare class ViewRenderError extends Error implements OrielError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status = 500;
+}
+/** Laravel's "View [x] not found." (InvalidArgumentException). */
+declare class ViewNotFoundError extends Error implements OrielError {
+    readonly view: string;
+    readonly searched: string[];
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status = 500;
+    constructor(view: string, searched?: string[]);
+}
+/** A view file that doesn't default-export a component. */
+declare class InvalidViewError extends Error implements OrielError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status = 500;
+}
+
+/**
+ * Laravel's FileViewFinder: 'posts.index' → <location>/posts/index.<ext> for the first location and extension
+ * that exist. Found paths are cached; misses are not, so a view created later is found.
+ */
+declare class FileViewFinder {
+    private readonly extensions;
+    static readonly defaultExtensions: string[];
+    private readonly locations;
+    private readonly hints;
+    private readonly views;
+    constructor(paths: string[], extensions?: string[]);
+    /** The absolute path of the view file. Throws ViewNotFoundError. */
+    find(name: string): string;
+    addLocation(path: string): void;
+    prependLocation(path: string): void;
+    /** Views under a namespace: addNamespace('mail', dir) makes 'mail::message' resolve to <dir>/message.tsx. */
+    addNamespace(namespace: string, hints: string | string[]): void;
+    replaceNamespace(namespace: string, hints: string | string[]): void;
+    getPaths(): string[];
+    getHints(): Record<string, string[]>;
+    /** Forget cached lookups. */
+    flush(): void;
+    /** [locations to search, relative file stem]. Dots become directories, so '..' can't climb out of a location. */
+    private parse;
+}
+
+/** What TsxView needs from its factory. */
+interface ViewEnvironment {
+    getShared(): Record<string, unknown>;
+    callComposer(view: View$1): Promise<void>;
+    load(path: string, name: string): Promise<Component>;
+}
+/**
+ * One view: its name, file and data. render() runs the composers, imports the file and renders its default
+ * export with { ...shared, ...data } as props. toHtml() returns the HTML of the last render().
+ */
+declare class TsxView implements View$1 {
+    private readonly environment;
+    readonly name: string;
+    readonly path: string;
+    private data;
+    private html;
+    constructor(environment: ViewEnvironment, name: string, path: string, data?: Record<string, unknown>);
+    with(key: string | Record<string, unknown>, value?: unknown): this;
+    /** The view's own data (Laravel's getData()). */
+    getData(): Record<string, unknown>;
+    /** Shared data overlaid with the view's data: exactly the props the component receives. */
+    gatherData(): Record<string, unknown>;
+    render(): Promise<string>;
+    toHtml(): string;
+}
+
+type Composer = (view: View$1) => void | Promise<void>;
+/** Laravel's view Factory: finds views by dotted name, shares data app-wide and runs view composers. */
+declare class Factory implements ViewFactory, ViewEnvironment {
+    private readonly finder;
+    private readonly shared;
+    private readonly composers;
+    constructor(finder: FileViewFinder);
+    /** Throws ViewNotFoundError ("View [x] not found.") when no file matches. */
+    make(name: string, data?: Record<string, unknown>): TsxView;
+    /** The first view that exists (Laravel's View::first()). */
+    first(names: string[], data?: Record<string, unknown>): TsxView;
+    exists(name: string): boolean;
+    /** App-wide data every view receives as props (view data wins on conflicts). */
+    share(key: string | Record<string, unknown>, value?: unknown): void;
+    getShared(): Record<string, unknown>;
+    /** Runs before matching views render. Patterns use `*` wildcards: 'posts.*', '*'. */
+    composer(views: string | string[], composer: Composer): void;
+    callComposer(view: View$1): Promise<void>;
+    /** Imports the view file (Node's module cache keeps it) and returns its default-export component. */
+    load(path: string, name: string): Promise<Component>;
+    addLocation(path: string): void;
+    addNamespace(namespace: string, hints: string | string[]): this;
+    getFinder(): FileViewFinder;
+}
+
+/** view() → the ViewFactory; view('posts.index', data) → a View to return from a route or render. */
+declare function view(): ViewFactory;
+declare function view(name: string, data?: Record<string, unknown>): View$1;
+/** Blade's @csrf / csrf_field(): the hidden _token input for the current request's session. */
+declare function csrfField(): HtmlString;
+/** Blade's @method('PUT') / method_field(): spoofs PUT/PATCH/DELETE from an HTML form. */
+declare function methodField(method: string): HtmlString;
+
+/** The View facade: View.make(), View.exists(), View.share(), View.composer(), View.first(), View.addNamespace(). */
+declare const View: Facade<Factory, object>;
+
+/** Binds the ViewFactory (resources/views by default) and merges the `view` config, like Laravel's config/view.php. */
+declare class ViewServiceProvider extends ServiceProvider {
+    register(): void;
+}
+
+export { Application as A, jsxs as B, ClassRegistry 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 ServiceProvider$1 as S, TsxView as T, View as V, type Class as a, type Abstract as b, ConfigRepository as c, type ClassValue as d, type Component as e, Fragment as f, HtmlString as g, type StyleObject as h, type ViewEnvironment as i, Factory as j, ViewNotFoundError as k, ViewRenderError as l, ViewServiceProvider as m, classNames as n, createElement as o, csrfField as p, e as q, isElement as r, isHtmlable as s, methodField as t, raw as u, renderToStream as v, renderToString as w, styleString as x, view as y, jsx as z };

package/dist/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export { f as Fragment, H as HtmlAttributes, J as JSX, z as jsx, B as jsxs } from './jsx-runtime-B8J6xq-7.js';

package/dist/jsx-runtime.js

@@ -0,0 +1,13 @@
+import {
+  Fragment,
+  jsx,
+  jsxs
+} from "./chunk-WI7E7Q46.js";
+import "./chunk-AI2RFMBT.js";
+import "./chunk-K6MAA3RM.js";
+export {
+  Fragment,
+  jsx,
+  jsxs
+};
+//# sourceMappingURL=jsx-runtime.js.map

package/dist/jsx-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}