@hybridly/vue 0.0.1-alpha.2 → 0.0.1-alpha.20

package/dist/index.d.ts

@@ -1,19 +1,23 @@
 import * as vue from 'vue';
-import { Plugin as Plugin$2, h, PropType, ComputedRef, ComponentOptions } from 'vue';
+import { App, Plugin as Plugin$2, h, PropType, ComputedRef, DeepReadonly } from 'vue';
 import * as _hybridly_core from '@hybridly/core';
-import { VisitPayload as VisitPayload$1, ResolveComponent as ResolveComponent$1, RouterContextOptions, Plugin as Plugin$1, RouterContext, Method as Method$1, VisitOptions as VisitOptions$1, UrlResolvable as UrlResolvable$1 } from '@hybridly/core';
-export { router } from '@hybridly/core';
+import { HybridPayload as HybridPayload$1, ResolveComponent as ResolveComponent$1, RouterContextOptions, Plugin as Plugin$1, RouterContext, Method as Method$1, HybridRequestOptions as HybridRequestOptions$1, UrlResolvable as UrlResolvable$1, registerHook as registerHook$1 } from '@hybridly/core';
+export { can, route, router } from '@hybridly/core';
 import { ProgressOptions } from '@hybridly/progress-plugin';
+import { Axios, AxiosResponse, AxiosProgressEvent } from 'axios';
 import * as _vue_shared from '@vue/shared';
 import { RequestData } from '@hybridly/utils';
-import { AxiosResponse, AxiosProgressEvent } from 'axios';
 
-declare function initializeHybridly(options: HybridlyOptions): Promise<void>;
+declare function initializeHybridly(options: HybridlyOptions): Promise<any>;
+/**
+ * Resolves a page component.
+ */
+declare function resolvePageComponent(name: string, pages: Record<string, any>, defaultLayout?: any): Promise<any>;
 interface HybridlyOptions {
     /** ID of the app element. */
     id?: string;
     /** Initial view data. */
-    payload?: VisitPayload$1;
+    payload?: HybridPayload$1;
     /** A collection of pages. */
     pages?: Record<string, any>;
     /** An optional default persistent layout. */
@@ -24,12 +28,18 @@ interface HybridlyOptions {
     serializer?: RouterContextOptions['serializer'];
     /** Clean up the host element's payload dataset after loading. */
     cleanup?: boolean;
+    /** Whether to set up the devtools plugin. */
+    devtools?: boolean;
     /** Progressbar options. */
     progress?: boolean | Partial<ProgressOptions>;
     /** Sets up the hybridly router. */
-    setup: (options: SetupArguments) => any;
+    setup?: (options: SetupArguments) => any;
     /** List of Hybridly plugins. */
     plugins?: Plugin$1[];
+    /** Callback that gets executed before Vue is mounted. */
+    enhanceVue?: (vue: App<Element>) => any;
+    /** Custom Axios instance. */
+    axios?: Axios;
 }
 interface SetupArguments {
     /** DOM element to mount Vue on. */
@@ -49,14 +59,15 @@ interface SetupArguments {
 declare const RouterLink: vue.DefineComponent<{
     href: {
         type: StringConstructor;
-        required: true;
+        required: false;
+        default: undefined;
     };
     as: {
-        type: (StringConstructor | ObjectConstructor)[];
+        type: (ObjectConstructor | StringConstructor)[];
         default: string;
     };
     method: {
-        type: PropType<Method$1>;
+        type: PropType<Method$1 | "get" | "post" | "put" | "patch" | "delete">;
         default: string;
     };
     data: {
@@ -72,20 +83,26 @@ declare const RouterLink: vue.DefineComponent<{
         default: boolean;
     };
     options: {
-        type: PropType<Omit<VisitOptions$1, "url" | "data" | "method">>;
+        type: PropType<Omit<HybridRequestOptions$1, "data" | "url" | "method">>;
         default: () => {};
     };
+    text: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
 }, (props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
     href: {
         type: StringConstructor;
-        required: true;
+        required: false;
+        default: undefined;
     };
     as: {
-        type: (StringConstructor | ObjectConstructor)[];
+        type: (ObjectConstructor | StringConstructor)[];
         default: string;
     };
     method: {
-        type: PropType<Method$1>;
+        type: PropType<Method$1 | "get" | "post" | "put" | "patch" | "delete">;
         default: string;
     };
     data: {
@@ -101,22 +118,28 @@ declare const RouterLink: vue.DefineComponent<{
         default: boolean;
     };
     options: {
-        type: PropType<Omit<VisitOptions$1, "url" | "data" | "method">>;
+        type: PropType<Omit<HybridRequestOptions$1, "data" | "url" | "method">>;
         default: () => {};
     };
+    text: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
 }>> & {}>>) => vue.VNode<vue.RendererNode, vue.RendererElement, {
     [key: string]: any;
 }>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
     href: {
         type: StringConstructor;
-        required: true;
+        required: false;
+        default: undefined;
     };
     as: {
-        type: (StringConstructor | ObjectConstructor)[];
+        type: (ObjectConstructor | StringConstructor)[];
         default: string;
     };
     method: {
-        type: PropType<Method$1>;
+        type: PropType<Method$1 | "get" | "post" | "put" | "patch" | "delete">;
         default: string;
     };
     data: {
@@ -132,13 +155,20 @@ declare const RouterLink: vue.DefineComponent<{
         default: boolean;
     };
     options: {
-        type: PropType<Omit<VisitOptions$1, "url" | "data" | "method">>;
+        type: PropType<Omit<HybridRequestOptions$1, "data" | "url" | "method">>;
         default: () => {};
     };
+    text: {
+        type: StringConstructor;
+        required: false;
+        default: undefined;
+    };
 }>>, {
     data: RequestData;
-    method: Method$1;
-    options: Omit<VisitOptions$1, "url" | "data" | "method">;
+    text: string;
+    href: string;
+    method: Method$1 | "get" | "post" | "put" | "patch" | "delete";
+    options: Omit<HybridRequestOptions$1, "data" | "url" | "method">;
     as: string | Record<string, any>;
     external: boolean;
     disabled: boolean;
@@ -174,51 +204,56 @@ interface AutoImportResolverOptions {
 
 /** Accesses all current properties. */
 declare function useProperties<T extends object, Global extends GlobalHybridlyProperties>(): vue.DeepReadonly<vue.UnwrapNestedRefs<T & Global>>;
+/**
+ * Accesses a property with the given type.
+ * @experimental Workaround for not being able to type `useProperty`, might be removed in the future.
+ */
+declare function useTypedProperty<T>(path: string, fallback?: T): ComputedRef<T>;
 /** Accesses a property with a dot notation. */
 declare function useProperty<T = GlobalHybridlyProperties, P extends Path<T> = Path<T>, Fallback extends PathValue<T, P> = PathValue<T, P>>(path: [P] extends [never] ? string : P, fallback?: Fallback): ComputedRef<[PathValue<T, P>] extends [never] ? Fallback : PathValue<T, P>>;
-declare type PathImpl<T, K extends keyof T> = K extends string ? T[K] extends Record<string, any> ? T[K] extends ArrayLike<any> ? K | `${K}.${PathImpl<T[K], Exclude<keyof T[K], keyof any[]>>}` : K | `${K}.${PathImpl<T[K], keyof T[K]>}` : K : never;
-declare type Path<T> = PathImpl<T, keyof T> | keyof T;
-declare type PathValue<T, P extends Path<T>> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K]> ? PathValue<T[K], Rest> : never : never : P extends keyof T ? T[P] : never;
+type PathImpl<T, K extends keyof T> = K extends string ? T[K] extends Record<string, any> ? T[K] extends ArrayLike<any> ? K | `${K}.${PathImpl<T[K], Exclude<keyof T[K], keyof any[]>>}` : K | `${K}.${PathImpl<T[K], keyof T[K]>}` : K : never;
+type Path<T> = PathImpl<T, keyof T> | keyof T;
+type PathValue<T, P extends Path<T>> = P extends `${infer K}.${infer Rest}` ? K extends keyof T ? Rest extends Path<T[K]> ? PathValue<T[K], Rest> : never : never : P extends keyof T ? T[P] : never;
 
-declare type MaybePromise<T> = T | Promise<T>;
+type MaybePromise<T> = T | Promise<T>;
 
-interface Hooks {
+interface RequestHooks {
     /**
-     * Called before anything when a visit is going to happen.
-     */
-    before: (options: VisitOptions) => MaybePromise<any | boolean>;
+         * Called before a navigation request is going to happen.
+         */
+    before: (options: HybridRequestOptions, context: InternalRouterContext) => MaybePromise<any | boolean>;
     /**
-     * Called before the request of a visit is going to happen.
+     * Called before the request of a navigation is going to happen.
      */
     start: (context: InternalRouterContext) => MaybePromise<any>;
     /**
      * Called when progress on the request is being made.
      */
-    progress: (progress: Progress) => MaybePromise<any>;
+    progress: (progress: Progress, context: InternalRouterContext) => MaybePromise<any>;
     /**
-     * Called when data is received after a request for a visit.
+     * Called when data is received after a request for a navigation.
      */
-    data: (response: AxiosResponse) => MaybePromise<any>;
+    data: (response: AxiosResponse, context: InternalRouterContext) => MaybePromise<any>;
     /**
      * Called when a request is successful and there is no error.
      */
-    success: (payload: VisitPayload) => MaybePromise<any>;
+    success: (payload: HybridPayload, context: InternalRouterContext) => MaybePromise<any>;
     /**
      * Called when a request is successful but there were errors.
      */
-    error: (errors: Errors) => MaybePromise<any>;
+    error: (errors: Errors, context: InternalRouterContext) => MaybePromise<any>;
     /**
      * Called when a request has been aborted.
      */
     abort: (context: InternalRouterContext) => MaybePromise<any>;
     /**
-     * Called when a response to a request is not a valid Hybridly response.
+     * Called when a response to a request is not a valid hybrid response.
      */
-    invalid: (response: AxiosResponse) => MaybePromise<void>;
+    invalid: (response: AxiosResponse, context: InternalRouterContext) => MaybePromise<void>;
     /**
      * Called when an unknowne exception was triggered.
      */
-    exception: (error: Error) => MaybePromise<void>;
+    exception: (error: Error, context: InternalRouterContext) => MaybePromise<void>;
     /**
      * Called whenever the request failed, for any reason, in addition to other hooks.
      */
@@ -227,19 +262,56 @@ interface Hooks {
      * Called after a request has been made, even if it didn't succeed.
      */
     after: (context: InternalRouterContext) => MaybePromise<void>;
+}
+interface Hooks extends RequestHooks {
+    /**
+         * Called when Hybridly's context is initialized.
+         */
+    initialized: (context: InternalRouterContext) => MaybePromise<void>;
+    /**
+     * Called after Hybridly's initial page load.
+     */
+    ready: (context: InternalRouterContext) => MaybePromise<void>;
     /**
-     * Called when a visit has been made and a page component has been navigated to.
+     * Called when a back-forward navigation occurs.
      */
-    navigate: (options: NavigationOptions) => MaybePromise<void>;
+    backForward: (state: any, context: InternalRouterContext) => MaybePromise<any>;
+    /**
+     * Called when a component navigation is being made.
+     */
+    navigating: (options: NavigationOptions, context: InternalRouterContext) => MaybePromise<void>;
+    /**
+     * Called when a component has been navigated to.
+     */
+    navigated: (options: NavigationOptions, context: InternalRouterContext) => MaybePromise<void>;
 }
 
-declare type UrlResolvable = string | URL | Location;
-declare type UrlTransformable = Partial<Omit<URL, 'searchParams' | 'toJSON' | 'toString'>>;
+interface RoutingConfiguration {
+    url: string;
+    port?: number;
+    defaults: Record<string, any>;
+    routes: Record<string, RouteDefinition>;
+}
+interface RouteDefinition {
+    uri: string;
+    method: Method[];
+    bindings: Record<string, string>;
+    domain?: string;
+    wheres?: Record<string, string>;
+    name: string;
+}
+
+type UrlResolvable = string | URL | Location;
+type UrlTransformable = BaseUrlTransformable | ((string: URL) => BaseUrlTransformable);
+type BaseUrlTransformable = Partial<Omit<URL, 'searchParams' | 'toJSON' | 'toString'>> & {
+    query?: any;
+    trailingSlash?: boolean;
+};
 
-declare type ConditionalNavigationOption = boolean | ((payload: VisitPayload) => boolean);
+type ConditionalNavigationOption = boolean | ((payload: HybridPayload) => boolean);
 interface NavigationOptions {
     /** View to navigate to. */
-    payload?: VisitPayload;
+    payload?: HybridPayload;
     /**
      * Whether to replace the current history state instead of adding
      * one. This affects the browser's "back" and "forward" features.
@@ -267,41 +339,50 @@ interface NavigationOptions {
      */
     updateHistoryState?: boolean;
     /**
-     * Defines whether this navigation is a back/forward visit from the popstate event.
+     * Defines whether this navigation is a back/forward navigation from the popstate event.
      * @internal This is an advanced property meant to be used internally.
      */
     isBackForward?: boolean;
 }
-declare type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-interface VisitOptions extends Omit<NavigationOptions, 'request'> {
-    /** The URL to visit. */
+type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface HybridRequestOptions extends Omit<NavigationOptions, 'payload'> {
+    /** The URL to navigation. */
     url?: UrlResolvable;
     /** HTTP verb to use for the request. */
-    method?: Method;
+    method?: Method | Lowercase<Method>;
     /** Body of the request. */
     data?: RequestData;
-    /** Which properties to update for this visit. Other properties will be ignored. */
+    /** Which properties to update for this navigation. Other properties will be ignored. */
     only?: string | string[];
-    /** Which properties not to update for this visit. Other properties will be updated. */
+    /** Which properties not to update for this navigation. Other properties will be updated. */
     except?: string | string[];
     /** Specific headers to add to the request. */
     headers?: Record<string, string>;
     /** The bag in which to put potential errors. */
     errorBag?: string;
-    /** Hooks for this visit. */
-    hooks?: Partial<Hooks>;
+    /** Hooks for this navigation. */
+    hooks?: Partial<RequestHooks>;
     /** If `true`, force the usage of a `FormData` object. */
     useFormData?: boolean;
+    /**
+     * If `false`, disable automatic form spoofing.
+     * @see https://laravel.com/docs/9.x/routing#form-method-spoofing
+     */
+    spoof?: boolean;
+    /**
+     * If `false`, does not trigger the progress bar for this request.
+     */
+    progress?: boolean;
 }
-/** An axios visit being made. */
-interface PendingVisit {
+/** A navigation being made. */
+interface PendingNavigation {
     /** The URL to which the request is being made. */
     url: URL;
     /** Abort controller associated to this request. */
     controller: AbortController;
-    /** Options for the associated visit. */
-    options: VisitOptions;
-    /** Visit identifier. */
+    /** Options for the associated hybrid request. */
+    options: HybridRequestOptions;
+    /** Navigation identifier. */
     id: string;
 }
 /** A page or dialog component. */
@@ -311,23 +392,25 @@ interface View {
     /** Properties to apply to the component. */
     properties: Properties;
 }
-declare type Property = null | string | number | boolean | Property[] | {
+type Property = null | string | number | boolean | Property[] | {
     [name: string]: Property;
 };
-declare type Properties = Record<string | number, Property>;
+type Properties = Record<string | number, Property>;
 interface SwapOptions<T> {
     /** The new component. */
     component: T;
+    /** The new properties. */
+    properties?: any;
     /** Whether to preserve the state of the component. */
     preserveState?: boolean;
 }
-declare type ViewComponent = any;
-declare type DialogComponent = any;
-declare type ResolveComponent = (name: string) => Promise<ViewComponent>;
-declare type SwapView = (options: SwapOptions<ViewComponent>) => Promise<void>;
-declare type SwapDialog = (options: SwapOptions<DialogComponent>) => Promise<void>;
-/** The payload of a visit request from the server. */
-interface VisitPayload {
+type ViewComponent = any;
+type DialogComponent = any;
+type ResolveComponent = (name: string) => Promise<ViewComponent>;
+type SwapView = (options: SwapOptions<ViewComponent>) => Promise<void>;
+type SwapDialog = (options: SwapOptions<DialogComponent>) => Promise<void>;
+/** The payload of a navigation request from the server. */
+interface HybridPayload {
     /** The view to use in this request. */
     view: View;
     /** An optional dialog. */
@@ -347,10 +430,9 @@ interface Errors {
     [key: string]: string;
 }
 
-interface Plugin {
+interface Plugin extends Partial<Hooks> {
+    /** Identifier of the plugin. */
     name: string;
-    initialized: (context: InternalRouterContext) => MaybePromise<void>;
-    hooks: Partial<Hooks>;
 }
 
 /** Router context. */
@@ -364,19 +446,23 @@ interface InternalRouterContext {
     /** The current local asset version. */
     version: string;
     /** The current adapter's functions. */
-    adapter: Adapter;
+    adapter: ResolvedAdapter;
     /** Scroll positions of the current page's DOM elements. */
     scrollRegions: ScrollRegion[];
     /** Arbitrary state. */
     state: Record<string, any>;
-    /** Currently pending visit. */
-    activeVisit?: PendingVisit;
+    /** Currently pending navigation. */
+    pendingNavigation?: PendingNavigation;
     /** History state serializer. */
     serializer: Serializer;
     /** List of plugins. */
     plugins: Plugin[];
     /** Global hooks. */
     hooks: Partial<Record<keyof Hooks, Array<Function>>>;
+    /** The Axios instance. */
+    axios: Axios;
+    /** Routing configuration. */
+    routing?: RoutingConfiguration;
 }
 /** Adapter-specific functions. */
 interface Adapter {
@@ -389,6 +475,9 @@ interface Adapter {
     /** Called when the context is updated. */
     update?: (context: InternalRouterContext) => void;
 }
+interface ResolvedAdapter extends Adapter {
+    updateRoutingConfiguration: (routing?: RoutingConfiguration) => void;
+}
 interface ScrollRegion {
     top: number;
     left: number;
@@ -402,11 +491,8 @@ interface Serializer {
 /** Accesses the hybridly context. */
 declare function useContext(): vue.ComputedRef<Readonly<InternalRouterContext> | undefined>;
 
-/** Gets the router. */
-declare function useRouter(): _hybridly_core.Router;
-
-declare type Fields = Record<string, any>;
-interface FormOptions<T extends Fields> extends Omit<VisitOptions$1, 'data' | 'url'> {
+type Fields = Record<string, any>;
+interface FormOptions<T extends Fields> extends Omit<HybridRequestOptions$1, 'data' | 'url'> {
     fields: T;
     url?: UrlResolvable$1 | (() => UrlResolvable$1);
     key?: string | false;
@@ -416,16 +502,33 @@ interface FormOptions<T extends Fields> extends Omit<VisitOptions$1, 'data' | 'u
 }
 declare function useForm<T extends Fields = Fields>(options: FormOptions<T>): {
     reset: (...keys: (keyof T)[]) => void;
-    initial: vue.UnwrapRef<vue.DeepReadonly<vue.UnwrapNestedRefs<T>>>;
     fields: vue.UnwrapRef<vue.UnwrapNestedRefs<T>>;
-    loaded: any;
-    submit: (optionsOverrides?: Omit<VisitOptions$1, 'data'>) => Promise<_hybridly_core.VisitResponse>;
     abort: () => void;
     setErrors: (incoming: Record<string, string>) => void;
-    clearErrors: () => void;
+    clearErrors: (...keys: (keyof T)[]) => void;
+    clearError: (key: keyof T) => void;
+    hasDirty: (...keys: (keyof T)[]) => boolean;
+    submitWithOptions: (optionsOverrides?: Omit<HybridRequestOptions$1, 'data'>) => Promise<_hybridly_core.NavigationResponse>;
+    submit: () => Promise<_hybridly_core.NavigationResponse>;
     hasErrors: boolean;
+    initial: vue.UnwrapRef<DeepReadonly<T>>;
+    loaded: any;
+    progress: {
+        readonly event: {
+            readonly loaded: number;
+            readonly total?: number | undefined;
+            readonly progress?: number | undefined;
+            readonly bytes: number;
+            readonly rate?: number | undefined;
+            readonly estimated?: number | undefined;
+            readonly upload?: boolean | undefined;
+            readonly download?: boolean | undefined;
+            readonly event?: any;
+        };
+        readonly percentage: number;
+    } | undefined;
     isDirty: boolean;
-    errors: vue.UnwrapRef<vue.DeepReadonly<vue.UnwrapNestedRefs<[Record<keyof T, string>] extends [vue.Ref<any>] ? vue.Ref<any> & Record<keyof T, string> : vue.Ref<vue.UnwrapRef<Record<keyof T, string>>>>>>;
+    errors: vue.UnwrapRef<DeepReadonly<[Record<keyof T, string>] extends [vue.Ref<any>] ? vue.Ref<any> & Record<keyof T, string> : vue.Ref<vue.UnwrapRef<Record<keyof T, string>>>>>;
     processing: boolean;
     successful: boolean;
     failed: boolean;
@@ -439,10 +542,10 @@ declare function useForm<T extends Fields = Fields>(options: FormOptions<T>): {
  */
 declare function useHistoryState<T = any>(key: string, initial: T): vue.Ref<vue.UnwrapRef<T>>;
 
-declare type BackForwardCallback = (context: RouterContext) => void;
+type BackForwardCallback = (context: RouterContext) => void;
 declare function useBackForward(): {
     onBackForward: (fn: BackForwardCallback) => void;
-    reloadOnBackForward: (options?: VisitOptions$1) => void;
+    reloadOnBackForward: (options?: HybridRequestOptions$1) => void;
 };
 
 declare global {
@@ -451,8 +554,8 @@ declare global {
      */
     interface Paginator<T = any> {
         data: T[];
-        meta?: PaginatorMeta;
-        links?: PaginatorLink[];
+        meta: PaginatorMeta;
+        links: PaginatorLink[];
     }
     /**
      * Paginated data without metadata wrapping.
@@ -521,35 +624,21 @@ declare function usePaginator<T = any>(paginator: UnwrappedPaginator<T> | Pagina
     to: number;
 };
 
-declare type Layout = ComponentOptions | (() => ComponentOptions) | [ComponentOptions];
+type Layout = any;
 /**
  * Sets the persistent layout for this page.
  */
-declare function useLayout(layout: Layout): void;
-
-interface RouterConfiguration {
-    url: string;
-    port?: number;
-    defaults: Record<string, any>;
-}
-interface RouteDefinition {
-    uri: string;
-    methods: Method$1[];
-    bindings: Record<string, string>;
-    domain?: string;
-    wheres?: Record<string, string>;
-}
-interface RouteCollection extends RouterConfiguration {
-    routes: Record<string, RouteDefinition>;
-}
-interface GlobalRouteCollection extends RouteCollection {
-}
-declare type RouteName = keyof GlobalRouteCollection['routes'];
-declare type RouteParameters<T extends RouteName> = Record<keyof GlobalRouteCollection['routes'][T]['bindings'], any> & Record<string, any>;
+declare function defineLayout<T extends Record<string, K>, K = any>(layout: Layout, properties?: T): void;
+declare function defineLayout(layouts: Layout[]): void;
+/**
+ * Sets or gets the properties for the current persistent layout.
+ */
+declare function defineLayoutProperties<T extends Record<string, K>, K = any>(properties: T): void;
 
 /**
- * Generates a route from the given route name.
+ * Registers a global hook.
+ * If called inside a component, unregisters after the component is unmounted.
  */
-declare function route<T extends RouteName>(name: T, parameters?: RouteParameters<T>, absolute?: boolean): string;
+declare const registerHook: typeof registerHook$1;
 
-export { AutoImportResolverOptions, GlobalRouteCollection, HybridlyImports, HybridlyResolver, Layout, RouteCollection, RouteDefinition, RouteName, RouteParameters, RouterConfiguration, RouterLink, initializeHybridly, route, useBackForward, useContext, useForm, useHistoryState, useLayout, usePaginator, useProperties, useProperty, useRouter };
+export { AutoImportResolverOptions, HybridlyImports, HybridlyResolver, Layout, RouterLink, defineLayout, defineLayoutProperties, initializeHybridly, registerHook, resolvePageComponent, useBackForward, useContext, useForm, useHistoryState, usePaginator, useProperties, useProperty, useTypedProperty };