@simonbackx/vue-app-navigation 1.28.0 → 2.0.0-alpha.0

package/dist/src/NavigationController.vue.d.ts

@@ -1,9 +1,28 @@
-import { Vue } from "vue-property-decorator";
-import { ComponentWithProperties } from "./ComponentWithProperties";
-import FramedComponent from "./FramedComponent.vue";
-import { PopOptions } from "./PopOptions";
-import { PushOptions } from "./PushOptions";
-export default class NavigationController extends Vue {
+import { PushOptions } from './PushOptions';
+import { PopOptions } from './PopOptions';
+import { ComponentWithProperties } from './ComponentWithProperties';
+import { PropType } from 'vue';
+
+declare const _default: import('vue').DefineComponent<{
+    root: {
+        required: true;
+        type: typeof ComponentWithProperties;
+    };
+    initialComponents: {
+        default: null;
+        type: PropType<ComponentWithProperties[] | null>;
+    };
+    animationType: {
+        default: string;
+        type: StringConstructor;
+    };
+    customProvide: {
+        type: ObjectConstructor;
+        default: null;
+    };
+}, {
+    originalPop: (options?: PopOptions | undefined) => void;
+}, {
     components: ComponentWithProperties[];
     mainComponent: ComponentWithProperties | null;
     transitionName: string;
@@ -12,41 +31,53 @@ export default class NavigationController extends Vue {
     previousScrollPosition: number;
     nextInternalScrollPosition: number;
     savedInternalScrollPositions: number[];
-    root: ComponentWithProperties;
-    initialComponents: ComponentWithProperties[] | null;
-    animationType: string;
-    child: FramedComponent;
-    beforeMount(): void;
+}, {}, {
     freezeSize(): void;
     growSize(width: number, height: number): void;
     unfreezeSize(): void;
-    getInternalScrollElement(element?: HTMLElement | null): HTMLElement | null;
+    getInternalScrollElement(element?: Element | null): HTMLElement | null;
     getScrollElement(element?: HTMLElement | null): HTMLElement;
     shouldAnimate(): boolean;
-    /**
-     * popOptions = how to handle the pop of replace. animated and count are ignored
-     * -> should get moved to separate configurations in the future
-     */
     push(options: PushOptions): Promise<void>;
-    /**
-     * Whether user interaction might prevent destructive navigation away from components.
-     */
     shouldNavigateAway(): Promise<boolean>;
     popToRoot(options?: PopOptions): Promise<ComponentWithProperties[] | undefined>;
-    getPoppableParent(): any | null;
-    /**
-     * force: whether "shouldNavigateAway" of child components is ignored
-     */
+    getPoppableParent(): import('vue').ComponentInternalInstance | null;
     pop(options?: PopOptions): Promise<ComponentWithProperties[] | undefined>;
-    beforeEnter(insertedElement: HTMLElement): void;
-    beforeLeave(_element: HTMLElement): void;
+    beforeEnter(insertedElement: Element): void;
+    beforeLeave(_element: Element): void;
     beforeBeforeEnterAnimation(): void;
     finishedEnterAnimation(): void;
-    enter(element: HTMLElement, done: any): void;
+    enter(element: any, done: () => void): void;
     getScrollOuterHeight(scrollElement: HTMLElement): number;
-    leave(element: HTMLElement, done: any): void;
-    afterLeave(element: HTMLElement): void;
-    afterEnter(element: HTMLElement): void;
-    enterCancelled(_element: HTMLElement): void;
-    destroyed(): void;
-}
+    leave(element: any, done: () => void): void;
+    afterLeave(element: any): void;
+    afterEnter(element: any): void;
+    enterCancelled(_element: any): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("didPush" | "didPop" | "showDetail" | "present")[], "didPush" | "didPop" | "showDetail" | "present", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    root: {
+        required: true;
+        type: typeof ComponentWithProperties;
+    };
+    initialComponents: {
+        default: null;
+        type: PropType<ComponentWithProperties[] | null>;
+    };
+    animationType: {
+        default: string;
+        type: StringConstructor;
+    };
+    customProvide: {
+        type: ObjectConstructor;
+        default: null;
+    };
+}>> & {
+    onDidPush?: ((...args: any[]) => any) | undefined;
+    onDidPop?: ((...args: any[]) => any) | undefined;
+    onShowDetail?: ((...args: any[]) => any) | undefined;
+    onPresent?: ((...args: any[]) => any) | undefined;
+}, {
+    customProvide: Record<string, any>;
+    initialComponents: ComponentWithProperties[] | null;
+    animationType: string;
+}, {}>;
+export default _default;

package/dist/src/NavigationMixin.d.ts

@@ -1,48 +1,29 @@
-import { Vue } from "vue-property-decorator";
-import { ComponentWithProperties } from "..";
-import NavigationController from "./NavigationController.vue";
+import { PushOptions } from './PushOptions';
+import { default as Popup } from './Popup.vue';
 import { PopOptions } from './PopOptions';
-import Popup from "./Popup.vue";
-import { PushOptions } from "./PushOptions";
-import Sheet from "./Sheet.vue";
-import SideView from "./SideView.vue";
-import SplitViewController from "./SplitViewController.vue";
-export declare class NavigationMixin extends Vue {
-    emitParents(event: string, data: any): void;
-    show(options: PushOptions | ComponentWithProperties): void;
-    present(options: PushOptions | ComponentWithProperties): void;
-    showDetail(options: PushOptions | ComponentWithProperties): void;
-    /**
-     * Call one of the pop listeners of a parent or grandparent. E.g. to go back in a navigation controller.
-     * @param options Options that should get applied to the pop of the first parent that listens for the pop event
-     */
-    pop(options?: PopOptions): void;
-    /**
-     * Same as pop, but instead dismisses the first parent that was displayed as a modal
-     * @param options Options that should get applied to the pop of the first modal navigation controller or popup that listens for the pop event
-     */
-    dismiss(options?: PopOptions): void;
-    get navigationController(): NavigationController | null;
-    get modalOrPopup(): NavigationController | Popup | Sheet | SideView | null;
-    get modalNavigationController(): NavigationController | null;
-    get splitViewController(): SplitViewController | null;
-    /**
-     * Return the first child of a parent that listens for the pop event
-     */
-    getPoppableParent(): any | null;
-    /**
-     * Whether the current navivation controller above this component can pop (it has more than one child). Excluding modal view controllers
-     */
-    canPop: boolean;
-    canDismiss: boolean;
-    activated(): void;
-    beforeMount(): void;
-    /**
-     * Return the first navigation controller that can get popped, excluding the modal navigation controller and the stack component
-     * Note: this shouldn't be a getter to disable vue caching getters
-     */
-    private getPoppableNavigationController;
-    isFocused(): boolean;
-    calculateCanPop(): boolean;
-    calculateCanDismiss(): boolean;
-}
+import { ComponentWithProperties } from './ComponentWithProperties';
+import { DefineComponent, Ref } from 'vue';
+
+export declare function usePop(): (options?: PopOptions) => void;
+export declare function useShowDetail(): (options: PushOptions | ComponentWithProperties) => Promise<void>;
+export declare function useShow(): (options: PushOptions | ComponentWithProperties) => Promise<void>;
+export declare function usePresent(): (options: PushOptions | ComponentWithProperties) => Promise<void>;
+export declare function useDismiss(): (options?: PopOptions) => Promise<void>;
+export declare function useCanPop(): Ref<boolean>;
+export declare function useCanDismiss(): Ref<boolean>;
+export declare function useFocused(): boolean | Ref<boolean>;
+/**
+ * @returns To detect whether you are in a popup
+ */
+export declare function usePopup(): Ref<InstanceType<typeof Popup> | null> | InstanceType<typeof Popup> | null;
+export declare const NavigationMixin: DefineComponent<{}, {
+    show: ReturnType<typeof useShow>;
+    showDetail: ReturnType<typeof useShowDetail>;
+    present: ReturnType<typeof usePresent>;
+    pop: ReturnType<typeof usePop>;
+    dismiss: ReturnType<typeof useDismiss>;
+    canPop: ReturnType<typeof useCanPop>;
+    canDismiss: ReturnType<typeof useCanDismiss>;
+    isFocused: ReturnType<typeof useFocused>;
+    popup: ReturnType<typeof usePopup>;
+}>;

package/dist/src/Plugin.d.ts

@@ -0,0 +1,5 @@
+import { App } from 'vue';
+
+export declare const VueAppNavigationPlugin: {
+    install(app: App): void;
+};

package/dist/src/Popup.vue.d.ts

@@ -1,17 +1,37 @@
-import { ComponentWithProperties } from "./ComponentWithProperties";
 import { PopOptions } from './PopOptions';
-import { ModalMixin } from './ModalMixin';
-export default class Popup extends ModalMixin {
+import { ComponentWithProperties } from './ComponentWithProperties';
+
+declare const _default: import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     root: ComponentWithProperties;
     className: string;
-    get buildClass(): string;
-    get shouldAppear(): boolean;
-    get pushDown(): 1 | 0 | 2;
-    get isFocused(): boolean;
-    onClick(event: any): void;
-    activated(): void;
-    deactivated(): void;
-    dismiss(options?: PopOptions): Promise<false | undefined>;
-    onKey(event: any): void;
-    shouldNavigateAway(): Promise<boolean>;
-}
+}>, {
+    className: string;
+}>, {
+    dismiss: import('vue').ShallowRef<(options?: PopOptions | undefined) => Promise<false | undefined>>;
+    pop: import('vue').ShallowRef<(options?: PopOptions | undefined) => Promise<false | undefined>>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    root: ComponentWithProperties;
+    className: string;
+}>, {
+    className: string;
+}>>>, {
+    className: string;
+}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/src/PushOptions.d.ts

@@ -1,4 +1,5 @@
-import { ComponentWithProperties, ModalDisplayStyle } from "./ComponentWithProperties";
+import { ComponentWithProperties, ModalDisplayStyle } from './ComponentWithProperties';
+
 export interface PushOptions {
     /**
      * Insert one or multiple components. Only the last one is animated if animations are required