@ionic/angular 8.8.9-dev.11780414486.1df2bd72 → 8.8.9-dev.11780493937.17fe092d

package/esm2022/common/providers/angular-delegate.mjs

@@ -0,0 +1,203 @@
+import { ApplicationRef, createComponent, inject, Injectable, InjectionToken, Injector, NgZone, } from '@angular/core';
+import { LIFECYCLE_DID_ENTER, LIFECYCLE_DID_LEAVE, LIFECYCLE_WILL_ENTER, LIFECYCLE_WILL_LEAVE, LIFECYCLE_WILL_UNLOAD, } from '@ionic/core/components';
+import { NavParams } from '../directives/navigation/nav-params';
+import { ConfigToken } from './config';
+import * as i0 from "@angular/core";
+// Token for injecting the modal element
+export const IonModalToken = new InjectionToken('IonModalToken');
+// TODO(FW-2827): types
+class AngularDelegate {
+    zone = inject(NgZone);
+    applicationRef = inject(ApplicationRef);
+    config = inject(ConfigToken);
+    create(environmentInjector, injector, elementReferenceKey, customInjector) {
+        return new AngularFrameworkDelegate(environmentInjector, injector, this.applicationRef, this.zone, elementReferenceKey, this.config.useSetInputAPI ?? false, customInjector);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularDelegate, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularDelegate });
+}
+export { AngularDelegate };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AngularDelegate, decorators: [{
+            type: Injectable
+        }] });
+export class AngularFrameworkDelegate {
+    environmentInjector;
+    injector;
+    applicationRef;
+    zone;
+    elementReferenceKey;
+    enableSignalsSupport;
+    customInjector;
+    elRefMap = new WeakMap();
+    elEventsMap = new WeakMap();
+    constructor(environmentInjector, injector, applicationRef, zone, elementReferenceKey, enableSignalsSupport, customInjector) {
+        this.environmentInjector = environmentInjector;
+        this.injector = injector;
+        this.applicationRef = applicationRef;
+        this.zone = zone;
+        this.elementReferenceKey = elementReferenceKey;
+        this.enableSignalsSupport = enableSignalsSupport;
+        this.customInjector = customInjector;
+    }
+    attachViewToDom(container, component, params, cssClasses) {
+        return this.zone.run(() => {
+            return new Promise((resolve) => {
+                const componentProps = {
+                    ...params,
+                };
+                /**
+                 * Ionic Angular passes a reference to a modal
+                 * or popover that can be accessed using a
+                 * variable in the overlay component. If
+                 * elementReferenceKey is defined, then we should
+                 * pass a reference to the component using
+                 * elementReferenceKey as the key.
+                 */
+                if (this.elementReferenceKey !== undefined) {
+                    componentProps[this.elementReferenceKey] = container;
+                }
+                const el = attachView(this.zone, this.environmentInjector, this.injector, this.applicationRef, this.elRefMap, this.elEventsMap, container, component, componentProps, cssClasses, this.elementReferenceKey, this.enableSignalsSupport, this.customInjector);
+                resolve(el);
+            });
+        });
+    }
+    removeViewFromDom(_container, component) {
+        return this.zone.run(() => {
+            return new Promise((resolve) => {
+                const componentRef = this.elRefMap.get(component);
+                if (componentRef) {
+                    componentRef.destroy();
+                    this.elRefMap.delete(component);
+                    const unbindEvents = this.elEventsMap.get(component);
+                    if (unbindEvents) {
+                        unbindEvents();
+                        this.elEventsMap.delete(component);
+                    }
+                }
+                resolve();
+            });
+        });
+    }
+}
+export const attachView = (zone, environmentInjector, injector, applicationRef, elRefMap, elEventsMap, container, component, params, cssClasses, elementReferenceKey, enableSignalsSupport, customInjector) => {
+    /**
+     * Wraps the injector with a custom injector that
+     * provides NavParams to the component.
+     *
+     * NavParams is a legacy feature from Ionic v3 that allows
+     * Angular developers to provide data to a component
+     * and access it by providing NavParams as a dependency
+     * in the constructor.
+     *
+     * The modern approach is to access the data directly
+     * from the component's class instance.
+     */
+    const providers = getProviders(params);
+    // If this is an ion-modal, provide the modal element as an injectable
+    // so components inside the modal can inject it directly
+    if (container.tagName.toLowerCase() === 'ion-modal') {
+        providers.push({
+            provide: IonModalToken,
+            useValue: container,
+        });
+    }
+    const childInjector = Injector.create({
+        providers,
+        parent: customInjector ?? injector,
+    });
+    const componentRef = createComponent(component, {
+        environmentInjector,
+        elementInjector: childInjector,
+    });
+    const instance = componentRef.instance;
+    const hostElement = componentRef.location.nativeElement;
+    if (params) {
+        /**
+         * For modals and popovers, a reference to the component is
+         * added to `params` during the call to attachViewToDom. If
+         * a reference using this name is already set, this means
+         * the app is trying to use the name as a component prop,
+         * which will cause collisions.
+         */
+        if (elementReferenceKey && instance[elementReferenceKey] !== undefined) {
+            console.error(`[Ionic Error]: ${elementReferenceKey} is a reserved property when using ${container.tagName.toLowerCase()}. Rename or remove the "${elementReferenceKey}" property from ${component.name}.`);
+        }
+        /**
+         * Angular 14.1 added support for setInput
+         * so we need to fall back to Object.assign
+         * for Angular 14.0.
+         */
+        if (enableSignalsSupport === true && componentRef.setInput !== undefined) {
+            const { modal, popover, ...otherParams } = params;
+            /**
+             * Any key/value pairs set in componentProps
+             * must be set as inputs on the component instance.
+             */
+            for (const key in otherParams) {
+                componentRef.setInput(key, otherParams[key]);
+            }
+            /**
+             * Using setInput will cause an error when
+             * setting modal/popover on a component that
+             * does not define them as an input. For backwards
+             * compatibility purposes we fall back to using
+             * Object.assign for these properties.
+             */
+            if (modal !== undefined) {
+                Object.assign(instance, { modal });
+            }
+            if (popover !== undefined) {
+                Object.assign(instance, { popover });
+            }
+        }
+        else {
+            Object.assign(instance, params);
+        }
+    }
+    if (cssClasses) {
+        for (const cssClass of cssClasses) {
+            hostElement.classList.add(cssClass);
+        }
+    }
+    const unbindEvents = bindLifecycleEvents(zone, instance, hostElement);
+    container.appendChild(hostElement);
+    applicationRef.attachView(componentRef.hostView);
+    elRefMap.set(hostElement, componentRef);
+    elEventsMap.set(hostElement, unbindEvents);
+    return hostElement;
+};
+const LIFECYCLES = [
+    LIFECYCLE_WILL_ENTER,
+    LIFECYCLE_DID_ENTER,
+    LIFECYCLE_WILL_LEAVE,
+    LIFECYCLE_DID_LEAVE,
+    LIFECYCLE_WILL_UNLOAD,
+];
+export const bindLifecycleEvents = (zone, instance, element) => {
+    return zone.run(() => {
+        const unregisters = LIFECYCLES.filter((eventName) => typeof instance[eventName] === 'function').map((eventName) => {
+            const handler = (ev) => instance[eventName](ev.detail);
+            element.addEventListener(eventName, handler);
+            return () => element.removeEventListener(eventName, handler);
+        });
+        return () => unregisters.forEach((fn) => fn());
+    });
+};
+const NavParamsToken = new InjectionToken('NavParamsToken');
+const getProviders = (params) => {
+    return [
+        {
+            provide: NavParamsToken,
+            useValue: params,
+        },
+        {
+            provide: NavParams,
+            useFactory: provideNavParamsInjectable,
+            deps: [NavParamsToken],
+        },
+    ];
+};
+const provideNavParamsInjectable = (params) => {
+    return new NavParams(params);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-delegate.js","sourceRoot":"","sources":["../../../../common/src/providers/angular-delegate.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef,\n  ComponentRef,\n  createComponent,\n  EnvironmentInjector,\n  inject,\n  Injectable,\n  InjectionToken,\n  Injector,\n  NgZone,\n} from '@angular/core';\nimport {\n  FrameworkDelegate,\n  LIFECYCLE_DID_ENTER,\n  LIFECYCLE_DID_LEAVE,\n  LIFECYCLE_WILL_ENTER,\n  LIFECYCLE_WILL_LEAVE,\n  LIFECYCLE_WILL_UNLOAD,\n} from '@ionic/core/components';\n\nimport { NavParams } from '../directives/navigation/nav-params';\n\nimport { ConfigToken } from './config';\n\n// Token for injecting the modal element\nexport const IonModalToken = new InjectionToken<HTMLIonModalElement>('IonModalToken');\n\n// TODO(FW-2827): types\n\n@Injectable()\nexport class AngularDelegate {\n  private zone = inject(NgZone);\n  private applicationRef = inject(ApplicationRef);\n  private config = inject(ConfigToken);\n\n  create(\n    environmentInjector: EnvironmentInjector,\n    injector: Injector,\n    elementReferenceKey?: string,\n    customInjector?: Injector\n  ): AngularFrameworkDelegate {\n    return new AngularFrameworkDelegate(\n      environmentInjector,\n      injector,\n      this.applicationRef,\n      this.zone,\n      elementReferenceKey,\n      this.config.useSetInputAPI ?? false,\n      customInjector\n    );\n  }\n}\n\nexport class AngularFrameworkDelegate implements FrameworkDelegate {\n  private elRefMap = new WeakMap<HTMLElement, ComponentRef<any>>();\n  private elEventsMap = new WeakMap<HTMLElement, () => void>();\n\n  constructor(\n    private environmentInjector: EnvironmentInjector,\n    private injector: Injector,\n    private applicationRef: ApplicationRef,\n    private zone: NgZone,\n    private elementReferenceKey?: string,\n    private enableSignalsSupport?: boolean,\n    private customInjector?: Injector\n  ) {}\n\n  attachViewToDom(container: any, component: any, params?: any, cssClasses?: string[]): Promise<any> {\n    return this.zone.run(() => {\n      return new Promise((resolve) => {\n        const componentProps = {\n          ...params,\n        };\n\n        /**\n         * Ionic Angular passes a reference to a modal\n         * or popover that can be accessed using a\n         * variable in the overlay component. If\n         * elementReferenceKey is defined, then we should\n         * pass a reference to the component using\n         * elementReferenceKey as the key.\n         */\n        if (this.elementReferenceKey !== undefined) {\n          componentProps[this.elementReferenceKey] = container;\n        }\n\n        const el = attachView(\n          this.zone,\n          this.environmentInjector,\n          this.injector,\n          this.applicationRef,\n          this.elRefMap,\n          this.elEventsMap,\n          container,\n          component,\n          componentProps,\n          cssClasses,\n          this.elementReferenceKey,\n          this.enableSignalsSupport,\n          this.customInjector\n        );\n        resolve(el);\n      });\n    });\n  }\n\n  removeViewFromDom(_container: any, component: any): Promise<void> {\n    return this.zone.run(() => {\n      return new Promise((resolve) => {\n        const componentRef = this.elRefMap.get(component);\n        if (componentRef) {\n          componentRef.destroy();\n          this.elRefMap.delete(component);\n          const unbindEvents = this.elEventsMap.get(component);\n          if (unbindEvents) {\n            unbindEvents();\n            this.elEventsMap.delete(component);\n          }\n        }\n        resolve();\n      });\n    });\n  }\n}\n\nexport const attachView = (\n  zone: NgZone,\n  environmentInjector: EnvironmentInjector,\n  injector: Injector,\n  applicationRef: ApplicationRef,\n  elRefMap: WeakMap<HTMLElement, ComponentRef<any>>,\n  elEventsMap: WeakMap<HTMLElement, () => void>,\n  container: any,\n  component: any,\n  params: any,\n  cssClasses: string[] | undefined,\n  elementReferenceKey: string | undefined,\n  enableSignalsSupport: boolean | undefined,\n  customInjector?: Injector\n): any => {\n  /**\n   * Wraps the injector with a custom injector that\n   * provides NavParams to the component.\n   *\n   * NavParams is a legacy feature from Ionic v3 that allows\n   * Angular developers to provide data to a component\n   * and access it by providing NavParams as a dependency\n   * in the constructor.\n   *\n   * The modern approach is to access the data directly\n   * from the component's class instance.\n   */\n  const providers = getProviders(params);\n\n  // If this is an ion-modal, provide the modal element as an injectable\n  // so components inside the modal can inject it directly\n  if (container.tagName.toLowerCase() === 'ion-modal') {\n    providers.push({\n      provide: IonModalToken,\n      useValue: container,\n    });\n  }\n\n  const childInjector = Injector.create({\n    providers,\n    parent: customInjector ?? injector,\n  });\n\n  const componentRef = createComponent<any>(component, {\n    environmentInjector,\n    elementInjector: childInjector,\n  });\n\n  const instance = componentRef.instance;\n  const hostElement = componentRef.location.nativeElement;\n\n  if (params) {\n    /**\n     * For modals and popovers, a reference to the component is\n     * added to `params` during the call to attachViewToDom. If\n     * a reference using this name is already set, this means\n     * the app is trying to use the name as a component prop,\n     * which will cause collisions.\n     */\n    if (elementReferenceKey && instance[elementReferenceKey] !== undefined) {\n      console.error(\n        `[Ionic Error]: ${elementReferenceKey} is a reserved property when using ${container.tagName.toLowerCase()}. Rename or remove the \"${elementReferenceKey}\" property from ${\n          component.name\n        }.`\n      );\n    }\n\n    /**\n     * Angular 14.1 added support for setInput\n     * so we need to fall back to Object.assign\n     * for Angular 14.0.\n     */\n    if (enableSignalsSupport === true && componentRef.setInput !== undefined) {\n      const { modal, popover, ...otherParams } = params;\n      /**\n       * Any key/value pairs set in componentProps\n       * must be set as inputs on the component instance.\n       */\n      for (const key in otherParams) {\n        componentRef.setInput(key, otherParams[key]);\n      }\n\n      /**\n       * Using setInput will cause an error when\n       * setting modal/popover on a component that\n       * does not define them as an input. For backwards\n       * compatibility purposes we fall back to using\n       * Object.assign for these properties.\n       */\n      if (modal !== undefined) {\n        Object.assign(instance, { modal });\n      }\n\n      if (popover !== undefined) {\n        Object.assign(instance, { popover });\n      }\n    } else {\n      Object.assign(instance, params);\n    }\n  }\n  if (cssClasses) {\n    for (const cssClass of cssClasses) {\n      hostElement.classList.add(cssClass);\n    }\n  }\n  const unbindEvents = bindLifecycleEvents(zone, instance, hostElement);\n  container.appendChild(hostElement);\n\n  applicationRef.attachView(componentRef.hostView);\n\n  elRefMap.set(hostElement, componentRef);\n  elEventsMap.set(hostElement, unbindEvents);\n  return hostElement;\n};\n\nconst LIFECYCLES = [\n  LIFECYCLE_WILL_ENTER,\n  LIFECYCLE_DID_ENTER,\n  LIFECYCLE_WILL_LEAVE,\n  LIFECYCLE_DID_LEAVE,\n  LIFECYCLE_WILL_UNLOAD,\n];\n\nexport const bindLifecycleEvents = (zone: NgZone, instance: any, element: HTMLElement): (() => void) => {\n  return zone.run(() => {\n    const unregisters = LIFECYCLES.filter((eventName) => typeof instance[eventName] === 'function').map((eventName) => {\n      const handler = (ev: any) => instance[eventName](ev.detail);\n      element.addEventListener(eventName, handler);\n      return () => element.removeEventListener(eventName, handler);\n    });\n    return () => unregisters.forEach((fn) => fn());\n  });\n};\n\nconst NavParamsToken = new InjectionToken<any>('NavParamsToken');\n\nconst getProviders = (params: { [key: string]: any }) => {\n  return [\n    {\n      provide: NavParamsToken,\n      useValue: params,\n    },\n    {\n      provide: NavParams,\n      useFactory: provideNavParamsInjectable,\n      deps: [NavParamsToken],\n    },\n  ];\n};\n\nconst provideNavParamsInjectable = (params: { [key: string]: any }) => {\n  return new NavParams(params);\n};\n"]}

package/esm2022/common/providers/config.mjs

@@ -0,0 +1,45 @@
+import { Injectable, InjectionToken } from '@angular/core';
+import * as i0 from "@angular/core";
+class Config {
+    get(key, fallback) {
+        const c = getConfig();
+        if (c) {
+            return c.get(key, fallback);
+        }
+        return null;
+    }
+    getBoolean(key, fallback) {
+        const c = getConfig();
+        if (c) {
+            return c.getBoolean(key, fallback);
+        }
+        return false;
+    }
+    getNumber(key, fallback) {
+        const c = getConfig();
+        if (c) {
+            return c.getNumber(key, fallback);
+        }
+        return 0;
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Config, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Config, providedIn: 'root' });
+}
+export { Config };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: Config, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+export const ConfigToken = new InjectionToken('USERCONFIG');
+const getConfig = () => {
+    if (typeof window !== 'undefined') {
+        const Ionic = window.Ionic;
+        if (Ionic?.config) {
+            return Ionic.config;
+        }
+    }
+    return null;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/providers/dom-controller.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class DomController {
+    /**
+     * Schedules a task to run during the READ phase of the next frame.
+     * This task should only read the DOM, but never modify it.
+     */
+    read(cb) {
+        getQueue().read(cb);
+    }
+    /**
+     * Schedules a task to run during the WRITE phase of the next frame.
+     * This task should write the DOM, but never READ it.
+     */
+    write(cb) {
+        getQueue().write(cb);
+    }
+    /** @nocollapse */ static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DomController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    /** @nocollapse */ static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DomController, providedIn: 'root' });
+}
+export { DomController };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DomController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+const getQueue = () => {
+    const win = typeof window !== 'undefined' ? window : null;
+    if (win != null) {
+        const Ionic = win.Ionic;
+        if (Ionic?.queue) {
+            return Ionic.queue;
+        }
+        return {
+            read: (cb) => win.requestAnimationFrame(cb),
+            write: (cb) => win.requestAnimationFrame(cb),
+        };
+    }
+    return {
+        read: (cb) => cb(),
+        write: (cb) => cb(),
+    };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/providers/menu-controller.mjs

@@ -0,0 +1,114 @@
+export class MenuController {
+    menuController;
+    constructor(menuController) {
+        this.menuController = menuController;
+    }
+    /**
+     * Programmatically open the Menu.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu is fully opened
+     */
+    open(menuId) {
+        return this.menuController.open(menuId);
+    }
+    /**
+     * Programmatically close the Menu. If no `menuId` is given as the first
+     * argument then it'll close any menu which is open. If a `menuId`
+     * is given then it'll close that exact menu.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu is fully closed
+     */
+    close(menuId) {
+        return this.menuController.close(menuId);
+    }
+    /**
+     * Toggle the menu. If it's closed, it will open, and if opened, it
+     * will close.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return returns a promise when the menu has been toggled
+     */
+    toggle(menuId) {
+        return this.menuController.toggle(menuId);
+    }
+    /**
+     * Used to enable or disable a menu. For example, there could be multiple
+     * left menus, but only one of them should be able to be opened at the same
+     * time. If there are multiple menus on the same side, then enabling one menu
+     * will also automatically disable all the others that are on the same side.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu, which is useful for chaining.
+     */
+    enable(shouldEnable, menuId) {
+        return this.menuController.enable(shouldEnable, menuId);
+    }
+    /**
+     * Used to enable or disable the ability to swipe open the menu.
+     * @param shouldEnable  True if it should be swipe-able, false if not.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu, which is useful for chaining.
+     */
+    swipeGesture(shouldEnable, menuId) {
+        return this.menuController.swipeGesture(shouldEnable, menuId);
+    }
+    /**
+     * @param [menuId] Optionally get the menu by its id, or side.
+     * @return Returns true if the specified menu is currently open, otherwise false.
+     * If the menuId is not specified, it returns true if ANY menu is currenly open.
+     */
+    isOpen(menuId) {
+        return this.menuController.isOpen(menuId);
+    }
+    /**
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns true if the menu is currently enabled, otherwise false.
+     */
+    isEnabled(menuId) {
+        return this.menuController.isEnabled(menuId);
+    }
+    /**
+     * Used to get a menu instance. If a `menuId` is not provided then it'll
+     * return the first menu found. If a `menuId` is `left` or `right`, then
+     * it'll return the enabled menu on that side. Otherwise, if a `menuId` is
+     * provided, then it'll try to find the menu using the menu's `id`
+     * property. If a menu is not found then it'll return `null`.
+     * @param [menuId]  Optionally get the menu by its id, or side.
+     * @return Returns the instance of the menu if found, otherwise `null`.
+     */
+    get(menuId) {
+        return this.menuController.get(menuId);
+    }
+    /**
+     * @return Returns the instance of the menu already opened, otherwise `null`.
+     */
+    getOpen() {
+        return this.menuController.getOpen();
+    }
+    /**
+     * @return Returns an array of all menu instances.
+     */
+    getMenus() {
+        return this.menuController.getMenus();
+    }
+    registerAnimation(name, animation) {
+        return this.menuController.registerAnimation(name, animation);
+    }
+    isAnimating() {
+        return this.menuController.isAnimating();
+    }
+    _getOpenSync() {
+        return this.menuController._getOpenSync();
+    }
+    _createAnimation(type, menuCmp) {
+        return this.menuController._createAnimation(type, menuCmp);
+    }
+    _register(menu) {
+        return this.menuController._register(menu);
+    }
+    _unregister(menu) {
+        return this.menuController._unregister(menu);
+    }
+    _setOpen(menu, shouldOpen, animated) {
+        return this.menuController._setOpen(menu, shouldOpen, animated);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu-controller.js","sourceRoot":"","sources":["../../../../common/src/providers/menu-controller.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,cAAc;IACL;IAApB,YAAoB,cAA+B;QAA/B,mBAAc,GAAd,cAAc,CAAiB;IAAG,CAAC;IAEvD;;;;OAIG;IACH,IAAI,CAAC,MAAe;QAClB,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAe;QACnB,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,MAAe;QACpB,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,YAAqB,EAAE,MAAe;QAC3C,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,YAAqB,EAAE,MAAe;QACjD,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAe;QACpB,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,MAAe;QACvB,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;;;OAQG;IACH,GAAG,CAAC,MAAe;QACjB,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;IACvC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,CAAC;IACxC,CAAC;IAED,iBAAiB,CAAC,IAAY,EAAE,SAA2B;QACzD,OAAO,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAChE,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC;IAC3C,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IAED,gBAAgB,CAAC,IAAY,EAAE,OAAc;QAC3C,OAAO,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;IAED,SAAS,CAAC,IAAW;QACnB,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED,WAAW,CAAC,IAAW;QACrB,OAAO,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAED,QAAQ,CAAC,IAAW,EAAE,UAAmB,EAAE,QAAiB;QAC1D,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;IAClE,CAAC;CACF","sourcesContent":["import type { MenuControllerI, AnimationBuilder, MenuI, Animation } from '@ionic/core/components';\n\nexport class MenuController implements MenuControllerI {\n  constructor(private menuController: MenuControllerI) {}\n\n  /**\n   * Programmatically open the Menu.\n   * @param [menuId]  Optionally get the menu by its id, or side.\n   * @return returns a promise when the menu is fully opened\n   */\n  open(menuId?: string): Promise<boolean> {\n    return this.menuController.open(menuId);\n  }\n\n  /**\n   * Programmatically close the Menu. If no `menuId` is given as the first\n   * argument then it'll close any menu which is open. If a `menuId`\n   * is given then it'll close that exact menu.\n   * @param [menuId]  Optionally get the menu by its id, or side.\n   * @return returns a promise when the menu is fully closed\n   */\n  close(menuId?: string): Promise<boolean> {\n    return this.menuController.close(menuId);\n  }\n\n  /**\n   * Toggle the menu. If it's closed, it will open, and if opened, it\n   * will close.\n   * @param [menuId]  Optionally get the menu by its id, or side.\n   * @return returns a promise when the menu has been toggled\n   */\n  toggle(menuId?: string): Promise<boolean> {\n    return this.menuController.toggle(menuId);\n  }\n\n  /**\n   * Used to enable or disable a menu. For example, there could be multiple\n   * left menus, but only one of them should be able to be opened at the same\n   * time. If there are multiple menus on the same side, then enabling one menu\n   * will also automatically disable all the others that are on the same side.\n   * @param [menuId]  Optionally get the menu by its id, or side.\n   * @return Returns the instance of the menu, which is useful for chaining.\n   */\n  enable(shouldEnable: boolean, menuId?: string): Promise<HTMLIonMenuElement | undefined> {\n    return this.menuController.enable(shouldEnable, menuId);\n  }\n\n  /**\n   * Used to enable or disable the ability to swipe open the menu.\n   * @param shouldEnable  True if it should be swipe-able, false if not.\n   * @param [menuId]  Optionally get the menu by its id, or side.\n   * @return Returns the instance of the menu, which is useful for chaining.\n   */\n  swipeGesture(shouldEnable: boolean, menuId?: string): Promise<HTMLIonMenuElement | undefined> {\n    return this.menuController.swipeGesture(shouldEnable, menuId);\n  }\n\n  /**\n   * @param [menuId] Optionally get the menu by its id, or side.\n   * @return Returns true if the specified menu is currently open, otherwise false.\n   * If the menuId is not specified, it returns true if ANY menu is currenly open.\n   */\n  isOpen(menuId?: string): Promise<boolean> {\n    return this.menuController.isOpen(menuId);\n  }\n\n  /**\n   * @param [menuId]  Optionally get the menu by its id, or side.\n   * @return Returns true if the menu is currently enabled, otherwise false.\n   */\n  isEnabled(menuId?: string): Promise<boolean> {\n    return this.menuController.isEnabled(menuId);\n  }\n\n  /**\n   * Used to get a menu instance. If a `menuId` is not provided then it'll\n   * return the first menu found. If a `menuId` is `left` or `right`, then\n   * it'll return the enabled menu on that side. Otherwise, if a `menuId` is\n   * provided, then it'll try to find the menu using the menu's `id`\n   * property. If a menu is not found then it'll return `null`.\n   * @param [menuId]  Optionally get the menu by its id, or side.\n   * @return Returns the instance of the menu if found, otherwise `null`.\n   */\n  get(menuId?: string): Promise<HTMLIonMenuElement | undefined> {\n    return this.menuController.get(menuId);\n  }\n\n  /**\n   * @return Returns the instance of the menu already opened, otherwise `null`.\n   */\n  getOpen(): Promise<HTMLIonMenuElement | undefined> {\n    return this.menuController.getOpen();\n  }\n\n  /**\n   * @return Returns an array of all menu instances.\n   */\n  getMenus(): Promise<HTMLIonMenuElement[]> {\n    return this.menuController.getMenus();\n  }\n\n  registerAnimation(name: string, animation: AnimationBuilder): void {\n    return this.menuController.registerAnimation(name, animation);\n  }\n\n  isAnimating(): Promise<boolean> {\n    return this.menuController.isAnimating();\n  }\n\n  _getOpenSync(): HTMLIonMenuElement | undefined {\n    return this.menuController._getOpenSync();\n  }\n\n  _createAnimation(type: string, menuCmp: MenuI): Promise<Animation> {\n    return this.menuController._createAnimation(type, menuCmp);\n  }\n\n  _register(menu: MenuI): void {\n    return this.menuController._register(menu);\n  }\n\n  _unregister(menu: MenuI): void {\n    return this.menuController._unregister(menu);\n  }\n\n  _setOpen(menu: MenuI, shouldOpen: boolean, animated: boolean): Promise<boolean> {\n    return this.menuController._setOpen(menu, shouldOpen, animated);\n  }\n}\n"]}