@hybridly/vue 0.0.1-dev.2

package/dist/index.d.ts

@@ -0,0 +1,555 @@
+import * as vue from 'vue';
+import { Plugin as Plugin$2, h, PropType, ComputedRef, ComponentOptions } 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 { ProgressOptions } from '@hybridly/progress-plugin';
+import * as _vue_shared from '@vue/shared';
+import { RequestData } from '@hybridly/utils';
+import { AxiosResponse, AxiosProgressEvent } from 'axios';
+
+declare function initializeHybridly(options: HybridlyOptions): Promise<void>;
+interface HybridlyOptions {
+    /** ID of the app element. */
+    id?: string;
+    /** Initial view data. */
+    payload?: VisitPayload$1;
+    /** A collection of pages. */
+    pages?: Record<string, any>;
+    /** An optional default persistent layout. */
+    layout?: any;
+    /** A custom component resolution option. */
+    resolve?: ResolveComponent$1;
+    /** Custom history state serialization functions. */
+    serializer?: RouterContextOptions['serializer'];
+    /** Clean up the host element's payload dataset after loading. */
+    cleanup?: boolean;
+    /** Progressbar options. */
+    progress?: boolean | Partial<ProgressOptions>;
+    /** Sets up the hybridly router. */
+    setup: (options: SetupArguments) => any;
+    /** List of Hybridly plugins. */
+    plugins?: Plugin$1[];
+}
+interface SetupArguments {
+    /** DOM element to mount Vue on. */
+    element: Element;
+    /** Hybridly wrapper component. */
+    wrapper: any;
+    /** Hybridly wrapper component properties. */
+    props: {
+        context: RouterContext;
+    };
+    /** Vue plugin that registers the devtools. */
+    hybridly: Plugin$2;
+    /** Renders the wrapper. */
+    render: () => ReturnType<typeof h>;
+}
+
+declare const RouterLink: vue.DefineComponent<{
+    href: {
+        type: StringConstructor;
+        required: true;
+    };
+    as: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: string;
+    };
+    method: {
+        type: PropType<Method$1>;
+        default: string;
+    };
+    data: {
+        type: PropType<RequestData>;
+        default: () => {};
+    };
+    external: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: PropType<Omit<VisitOptions$1, "url" | "data" | "method">>;
+        default: () => {};
+    };
+}, (props: Readonly<_vue_shared.LooseRequired<Readonly<vue.ExtractPropTypes<{
+    href: {
+        type: StringConstructor;
+        required: true;
+    };
+    as: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: string;
+    };
+    method: {
+        type: PropType<Method$1>;
+        default: string;
+    };
+    data: {
+        type: PropType<RequestData>;
+        default: () => {};
+    };
+    external: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: PropType<Omit<VisitOptions$1, "url" | "data" | "method">>;
+        default: () => {};
+    };
+}>> & {}>>) => 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;
+    };
+    as: {
+        type: (StringConstructor | ObjectConstructor)[];
+        default: string;
+    };
+    method: {
+        type: PropType<Method$1>;
+        default: string;
+    };
+    data: {
+        type: PropType<RequestData>;
+        default: () => {};
+    };
+    external: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: PropType<Omit<VisitOptions$1, "url" | "data" | "method">>;
+        default: () => {};
+    };
+}>>, {
+    data: RequestData;
+    method: Method$1;
+    options: Omit<VisitOptions$1, "url" | "data" | "method">;
+    as: string | Record<string, any>;
+    external: boolean;
+    disabled: boolean;
+}>;
+
+/**
+ * Preset for `unplugin-auto-imports`.
+ * @see https://github.com/antfu/unplugin-auto-imports
+ */
+declare const HybridlyImports: {
+    'hybridly/vue': string[];
+    hybridly: string[];
+};
+
+/**
+ * Resolver for `unplugin-vue-components`.
+ * @see https://github.com/antfu/unplugin-vue-components
+ */
+declare function HybridlyResolver(options?: AutoImportResolverOptions): {
+    type: "component";
+    resolve: (name: string) => {
+        name: string;
+        as: string;
+        from: string;
+    } | undefined;
+};
+interface AutoImportResolverOptions {
+    /**
+     * Custom name for the link component.
+     */
+    linkName?: string;
+}
+
+/** Accesses all current properties. */
+declare function useProperties<T extends object, Global extends GlobalHybridlyProperties>(): vue.DeepReadonly<vue.UnwrapNestedRefs<T & Global>>;
+/** 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;
+
+declare type MaybePromise<T> = T | Promise<T>;
+
+interface Hooks {
+    /**
+     * Called before anything when a visit is going to happen.
+     */
+    before: (options: VisitOptions) => MaybePromise<any | boolean>;
+    /**
+     * Called before the request of a visit is going to happen.
+     */
+    start: (context: InternalRouterContext) => MaybePromise<any>;
+    /**
+     * Called when progress on the request is being made.
+     */
+    progress: (progress: Progress) => MaybePromise<any>;
+    /**
+     * Called when data is received after a request for a visit.
+     */
+    data: (response: AxiosResponse) => MaybePromise<any>;
+    /**
+     * Called when a request is successful and there is no error.
+     */
+    success: (payload: VisitPayload) => MaybePromise<any>;
+    /**
+     * Called when a request is successful but there were errors.
+     */
+    error: (errors: Errors) => 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.
+     */
+    invalid: (response: AxiosResponse) => MaybePromise<void>;
+    /**
+     * Called when an unknowne exception was triggered.
+     */
+    exception: (error: Error) => MaybePromise<void>;
+    /**
+     * Called whenever the request failed, for any reason, in addition to other hooks.
+     */
+    fail: (context: InternalRouterContext) => MaybePromise<void>;
+    /**
+     * Called after a request has been made, even if it didn't succeed.
+     */
+    after: (context: InternalRouterContext) => MaybePromise<void>;
+    /**
+     * Called when a visit has been made and a page component has been navigated to.
+     */
+    navigate: (options: NavigationOptions) => MaybePromise<void>;
+}
+
+declare type UrlResolvable = string | URL | Location;
+declare type UrlTransformable = Partial<Omit<URL, 'searchParams' | 'toJSON' | 'toString'>>;
+
+declare type ConditionalNavigationOption = boolean | ((payload: VisitPayload) => boolean);
+interface NavigationOptions {
+    /** View to navigate to. */
+    payload?: VisitPayload;
+    /**
+     * Whether to replace the current history state instead of adding
+     * one. This affects the browser's "back" and "forward" features.
+     */
+    replace?: ConditionalNavigationOption;
+    /** Whether to preserve the current scrollbar position. */
+    preserveScroll?: ConditionalNavigationOption;
+    /** Whether to preserve the current page component's state. */
+    preserveState?: ConditionalNavigationOption;
+    /** Whether to preserve the current URL. */
+    preserveUrl?: ConditionalNavigationOption;
+    /**
+     * Properties of the given URL to override.
+     * @example
+     * ```ts
+     * router.get('/login?redirect=/', {
+     * 	transformUrl: { search: '' }
+     * }
+     * ```
+     */
+    transformUrl?: UrlTransformable;
+    /**
+     * Defines whether the history state should be updated.
+     * @internal This is an advanced property meant to be used internally.
+     */
+    updateHistoryState?: boolean;
+    /**
+     * Defines whether this navigation is a back/forward visit 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. */
+    url?: UrlResolvable;
+    /** HTTP verb to use for the request. */
+    method?: Method;
+    /** Body of the request. */
+    data?: RequestData;
+    /** Which properties to update for this visit. Other properties will be ignored. */
+    only?: string | string[];
+    /** Which properties not to update for this visit. 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>;
+    /** If `true`, force the usage of a `FormData` object. */
+    useFormData?: boolean;
+}
+/** An axios visit being made. */
+interface PendingVisit {
+    /** 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. */
+    id: string;
+}
+/** A page or dialog component. */
+interface View {
+    /** Name of the component to use. */
+    name: string;
+    /** Properties to apply to the component. */
+    properties: Properties;
+}
+declare type Property = null | string | number | boolean | Property[] | {
+    [name: string]: Property;
+};
+declare type Properties = Record<string | number, Property>;
+interface SwapOptions<T> {
+    /** The new component. */
+    component: T;
+    /** 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 {
+    /** The view to use in this request. */
+    view: View;
+    /** An optional dialog. */
+    dialog?: View;
+    /** The current page URL. */
+    url: string;
+    /** The current asset version. */
+    version: string;
+}
+interface Progress {
+    /** Base event. */
+    event: AxiosProgressEvent;
+    /** Computed percentage. */
+    percentage: Readonly<number>;
+}
+interface Errors {
+    [key: string]: string;
+}
+
+interface Plugin {
+    name: string;
+    initialized: (context: InternalRouterContext) => MaybePromise<void>;
+    hooks: Partial<Hooks>;
+}
+
+/** Router context. */
+interface InternalRouterContext {
+    /** The current, normalized URL. */
+    url: string;
+    /** The current view. */
+    view: View;
+    /** The current, optional dialog. */
+    dialog?: View;
+    /** The current local asset version. */
+    version: string;
+    /** The current adapter's functions. */
+    adapter: Adapter;
+    /** Scroll positions of the current page's DOM elements. */
+    scrollRegions: ScrollRegion[];
+    /** Arbitrary state. */
+    state: Record<string, any>;
+    /** Currently pending visit. */
+    activeVisit?: PendingVisit;
+    /** History state serializer. */
+    serializer: Serializer;
+    /** List of plugins. */
+    plugins: Plugin[];
+    /** Global hooks. */
+    hooks: Partial<Record<keyof Hooks, Array<Function>>>;
+}
+/** Adapter-specific functions. */
+interface Adapter {
+    /** Resolves a component from the given name. */
+    resolveComponent: ResolveComponent;
+    /** Swaps to the given view. */
+    swapView: SwapView;
+    /** Swaps to the given dialog. */
+    swapDialog: SwapDialog;
+    /** Called when the context is updated. */
+    update?: (context: InternalRouterContext) => void;
+}
+interface ScrollRegion {
+    top: number;
+    left: number;
+}
+/** Provides methods to serialize the state into the history state. */
+interface Serializer {
+    serialize: <T>(view: T) => any;
+    unserialize: <T>(state: any) => T;
+}
+
+/** 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'> {
+    fields: T;
+    url?: UrlResolvable$1 | (() => UrlResolvable$1);
+    key?: string | false;
+    timeout?: number;
+    reset?: boolean;
+    transform?: (fields: T) => Fields;
+}
+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;
+    hasErrors: boolean;
+    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>>>>>>;
+    processing: boolean;
+    successful: boolean;
+    failed: boolean;
+    recentlySuccessful: boolean;
+    recentlyFailed: boolean;
+};
+
+/**
+ * Returns a ref with a value saved in the history state through Hybridly.
+ * The state is linked to a specific browser history entry.
+ */
+declare function useHistoryState<T = any>(key: string, initial: T): vue.Ref<vue.UnwrapRef<T>>;
+
+declare type BackForwardCallback = (context: RouterContext) => void;
+declare function useBackForward(): {
+    onBackForward: (fn: BackForwardCallback) => void;
+    reloadOnBackForward: (options?: VisitOptions$1) => void;
+};
+
+declare global {
+    /**
+     * Paginated data with metadata in a `meta` wrap.
+     */
+    interface Paginator<T = any> {
+        data: T[];
+        meta?: PaginatorMeta;
+        links?: PaginatorLink[];
+    }
+    /**
+     * Paginated data without metadata wrapping.
+     */
+    interface UnwrappedPaginator<T = any> extends PaginatorMeta {
+        data: T[];
+        links: PaginatorLink[];
+    }
+}
+interface PaginatorLink {
+    url?: string;
+    label: string;
+    active: boolean;
+}
+interface PaginatorMeta {
+    path: string;
+    from: number;
+    to: number;
+    total: number;
+    per_page: number;
+    current_page: number;
+    last_page: number;
+    first_page_url: string;
+    last_page_url: string;
+    next_page_url: string | undefined;
+    prev_page_url: string | undefined;
+    links?: PaginatorLink[];
+}
+interface Item {
+    url: string | undefined;
+    label: string;
+    isPage: boolean;
+    isActive: boolean;
+    isPrevious: boolean;
+    isNext: boolean;
+    isCurrent: boolean;
+    isSeparator: boolean;
+}
+declare function usePaginator<T = any>(paginator: UnwrappedPaginator<T> | Paginator<T> | PaginatorMeta): {
+    pages: Item[];
+    items: Item[];
+    previous: Item;
+    next: Item;
+    first: {
+        isActive: boolean;
+        label: string;
+        url: string | undefined;
+        isPage: boolean;
+        isPrevious: boolean;
+        isNext: boolean;
+        isCurrent: boolean;
+        isSeparator: boolean;
+    };
+    last: {
+        isActive: boolean;
+        label: string;
+        url: string | undefined;
+        isPage: boolean;
+        isPrevious: boolean;
+        isNext: boolean;
+        isCurrent: boolean;
+        isSeparator: boolean;
+    };
+    total: number;
+    from: number;
+    to: number;
+};
+
+declare type Layout = ComponentOptions | (() => ComponentOptions) | [ComponentOptions];
+/**
+ * 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>;
+
+/**
+ * Generates a route from the given route name.
+ */
+declare function route<T extends RouteName>(name: T, parameters?: RouteParameters<T>, absolute?: boolean): string;
+
+export { AutoImportResolverOptions, GlobalRouteCollection, HybridlyImports, HybridlyResolver, Layout, RouteCollection, RouteDefinition, RouteName, RouteParameters, RouterConfiguration, RouterLink, initializeHybridly, route, useBackForward, useContext, useForm, useHistoryState, useLayout, usePaginator, useProperties, useProperty, useRouter };