@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

package/dist/runtime/composables/popper.d.ts

@@ -0,0 +1,529 @@
+import type { Ref } from 'vue';
+import type { VirtualElement } from '@popperjs/core/lib/popper-lite';
+import type { Instance } from '@popperjs/core';
+import type { MaybeElement } from '@vueuse/core';
+import type { PopperOptions } from '../types/popper.js';
+export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>>) => Instance;
+export declare function usePopper({ locked, overflowPadding, offsetDistance, offsetSkid, gpuAcceleration, adaptive, scroll, resize, placement, strategy, }: PopperOptions, virtualReference?: Ref<Element | VirtualElement>): readonly [Ref<MaybeElement, MaybeElement>, Ref<MaybeElement, MaybeElement>, Ref<{
+    state: {
+        elements: {
+            reference: Element | {
+                getBoundingClientRect: () => ClientRect | DOMRect;
+                contextElement?: Element | undefined;
+            };
+            popper: HTMLElement;
+            arrow?: HTMLElement | undefined;
+        };
+        options: {
+            placement: import("@popperjs/core").Placement;
+            modifiers: any[];
+            strategy: import("@popperjs/core").PositioningStrategy;
+            onFirstUpdate?: ((arg0: Partial<import("@popperjs/core").State>) => void) | undefined;
+        };
+        placement: import("@popperjs/core").Placement;
+        strategy: import("@popperjs/core").PositioningStrategy;
+        orderedModifiers: {
+            name: any;
+            enabled: boolean;
+            phase: import("@popperjs/core").ModifierPhases;
+            requires?: Array<string> | undefined;
+            requiresIfExists?: Array<string> | undefined;
+            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => import("@popperjs/core").State | void;
+            effect?: ((arg0: import("@popperjs/core").ModifierArguments<any>) => (() => void) | void) | undefined;
+            options?: Partial<any> | undefined;
+            data?: import("@popperjs/core").Obj | undefined;
+        }[];
+        rects: {
+            reference: {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            popper: {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+        };
+        scrollParents: {
+            reference: (Element | {
+                innerHeight: number;
+                offsetHeight: number;
+                innerWidth: number;
+                offsetWidth: number;
+                pageXOffset: number;
+                pageYOffset: number;
+                getComputedStyle: typeof getComputedStyle;
+                addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                Element: Element;
+                HTMLElement: HTMLElement;
+                Node: Node;
+                toString: () => "[object Window]";
+                devicePixelRatio: number;
+                visualViewport?: {
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                } | undefined;
+                ShadowRoot: ShadowRoot;
+            } | {
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
+                width: number;
+                height: number;
+                offsetLeft: number;
+                offsetTop: number;
+                scale: number;
+            })[];
+            popper: (Element | {
+                innerHeight: number;
+                offsetHeight: number;
+                innerWidth: number;
+                offsetWidth: number;
+                pageXOffset: number;
+                pageYOffset: number;
+                getComputedStyle: typeof getComputedStyle;
+                addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                Element: Element;
+                HTMLElement: HTMLElement;
+                Node: Node;
+                toString: () => "[object Window]";
+                devicePixelRatio: number;
+                visualViewport?: {
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                } | undefined;
+                ShadowRoot: ShadowRoot;
+            } | {
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
+                width: number;
+                height: number;
+                offsetLeft: number;
+                offsetTop: number;
+                scale: number;
+            })[];
+        };
+        styles: {
+            [key: string]: Partial<CSSStyleDeclaration>;
+        };
+        attributes: {
+            [key: string]: {
+                [key: string]: string | boolean;
+            };
+        };
+        modifiersData: {
+            [x: string]: any;
+            arrow?: {
+                x?: number | undefined;
+                y?: number | undefined;
+                centerOffset: number;
+            } | undefined;
+            hide?: {
+                isReferenceHidden: boolean;
+                hasPopperEscaped: boolean;
+                referenceClippingOffsets: {
+                    top: number;
+                    left: number;
+                    right: number;
+                    bottom: number;
+                };
+                popperEscapeOffsets: {
+                    top: number;
+                    left: number;
+                    right: number;
+                    bottom: number;
+                };
+            } | undefined;
+            offset?: {
+                auto?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "auto-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "auto-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                top?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                bottom?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                right?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                left?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "top-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "top-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "bottom-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "bottom-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "right-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "right-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "left-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "left-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+            } | undefined;
+            preventOverflow?: {
+                y: number;
+                x: number;
+            } | undefined;
+            popperOffsets?: {
+                y: number;
+                x: number;
+            } | undefined;
+        };
+        reset: boolean;
+    };
+    destroy: () => void;
+    forceUpdate: () => void;
+    update: () => Promise<Partial<import("@popperjs/core").State>>;
+    setOptions: (setOptionsAction: Partial<import("@popperjs/core").OptionsGeneric<any>> | ((prev: Partial<import("@popperjs/core").OptionsGeneric<any>>) => Partial<import("@popperjs/core").OptionsGeneric<any>>)) => Promise<Partial<import("@popperjs/core").State>>;
+} | null, Instance | {
+    state: {
+        elements: {
+            reference: Element | {
+                getBoundingClientRect: () => ClientRect | DOMRect;
+                contextElement?: Element | undefined;
+            };
+            popper: HTMLElement;
+            arrow?: HTMLElement | undefined;
+        };
+        options: {
+            placement: import("@popperjs/core").Placement;
+            modifiers: any[];
+            strategy: import("@popperjs/core").PositioningStrategy;
+            onFirstUpdate?: ((arg0: Partial<import("@popperjs/core").State>) => void) | undefined;
+        };
+        placement: import("@popperjs/core").Placement;
+        strategy: import("@popperjs/core").PositioningStrategy;
+        orderedModifiers: {
+            name: any;
+            enabled: boolean;
+            phase: import("@popperjs/core").ModifierPhases;
+            requires?: Array<string> | undefined;
+            requiresIfExists?: Array<string> | undefined;
+            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => import("@popperjs/core").State | void;
+            effect?: ((arg0: import("@popperjs/core").ModifierArguments<any>) => (() => void) | void) | undefined;
+            options?: Partial<any> | undefined;
+            data?: import("@popperjs/core").Obj | undefined;
+        }[];
+        rects: {
+            reference: {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+            popper: {
+                width: number;
+                height: number;
+                x: number;
+                y: number;
+            };
+        };
+        scrollParents: {
+            reference: (Element | {
+                innerHeight: number;
+                offsetHeight: number;
+                innerWidth: number;
+                offsetWidth: number;
+                pageXOffset: number;
+                pageYOffset: number;
+                getComputedStyle: typeof getComputedStyle;
+                addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                Element: Element;
+                HTMLElement: HTMLElement;
+                Node: Node;
+                toString: () => "[object Window]";
+                devicePixelRatio: number;
+                visualViewport?: {
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                } | undefined;
+                ShadowRoot: ShadowRoot;
+            } | {
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
+                width: number;
+                height: number;
+                offsetLeft: number;
+                offsetTop: number;
+                scale: number;
+            })[];
+            popper: (Element | {
+                innerHeight: number;
+                offsetHeight: number;
+                innerWidth: number;
+                offsetWidth: number;
+                pageXOffset: number;
+                pageYOffset: number;
+                getComputedStyle: typeof getComputedStyle;
+                addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
+                Element: Element;
+                HTMLElement: HTMLElement;
+                Node: Node;
+                toString: () => "[object Window]";
+                devicePixelRatio: number;
+                visualViewport?: {
+                    addEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    };
+                    dispatchEvent: {
+                        (event: Event): boolean;
+                        (event: Event): boolean;
+                    };
+                    removeEventListener: {
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    };
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                } | undefined;
+                ShadowRoot: ShadowRoot;
+            } | {
+                addEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                };
+                dispatchEvent: {
+                    (event: Event): boolean;
+                    (event: Event): boolean;
+                };
+                removeEventListener: {
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                };
+                width: number;
+                height: number;
+                offsetLeft: number;
+                offsetTop: number;
+                scale: number;
+            })[];
+        };
+        styles: {
+            [key: string]: Partial<CSSStyleDeclaration>;
+        };
+        attributes: {
+            [key: string]: {
+                [key: string]: string | boolean;
+            };
+        };
+        modifiersData: {
+            [x: string]: any;
+            arrow?: {
+                x?: number | undefined;
+                y?: number | undefined;
+                centerOffset: number;
+            } | undefined;
+            hide?: {
+                isReferenceHidden: boolean;
+                hasPopperEscaped: boolean;
+                referenceClippingOffsets: {
+                    top: number;
+                    left: number;
+                    right: number;
+                    bottom: number;
+                };
+                popperEscapeOffsets: {
+                    top: number;
+                    left: number;
+                    right: number;
+                    bottom: number;
+                };
+            } | undefined;
+            offset?: {
+                auto?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "auto-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "auto-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                top?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                bottom?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                right?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                left?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "top-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "top-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "bottom-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "bottom-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "right-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "right-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "left-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "left-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+            } | undefined;
+            preventOverflow?: {
+                y: number;
+                x: number;
+            } | undefined;
+            popperOffsets?: {
+                y: number;
+                x: number;
+            } | undefined;
+        };
+        reset: boolean;
+    };
+    destroy: () => void;
+    forceUpdate: () => void;
+    update: () => Promise<Partial<import("@popperjs/core").State>>;
+    setOptions: (setOptionsAction: Partial<import("@popperjs/core").OptionsGeneric<any>> | ((prev: Partial<import("@popperjs/core").OptionsGeneric<any>>) => Partial<import("@popperjs/core").OptionsGeneric<any>>)) => Promise<Partial<import("@popperjs/core").State>>;
+} | null>];

package/dist/runtime/composables/popper.js

@@ -0,0 +1,104 @@
+import { ref, onMounted, watchEffect } from "vue";
+import { popperGenerator, defaultModifiers } from "@popperjs/core/lib/popper-lite";
+import { omitBy, isUndefined } from "lodash-es";
+import flip from "@popperjs/core/lib/modifiers/flip";
+import offset from "@popperjs/core/lib/modifiers/offset";
+import preventOverflow from "@popperjs/core/lib/modifiers/preventOverflow";
+import computeStyles from "@popperjs/core/lib/modifiers/computeStyles";
+import eventListeners from "@popperjs/core/lib/modifiers/eventListeners";
+import { unrefElement } from "@vueuse/core";
+export const createPopper = popperGenerator({
+  defaultModifiers: [...defaultModifiers, offset, flip, preventOverflow, computeStyles, eventListeners]
+});
+export function usePopper({
+  locked = false,
+  overflowPadding = 8,
+  offsetDistance = 8,
+  offsetSkid = 0,
+  gpuAcceleration = true,
+  adaptive = true,
+  scroll = true,
+  resize = true,
+  placement,
+  strategy
+}, virtualReference) {
+  const reference = ref(null);
+  const popper = ref(null);
+  const instance = ref(null);
+  onMounted(() => {
+    watchEffect((onInvalidate) => {
+      if (!popper.value) {
+        return;
+      }
+      if (!reference.value && !virtualReference?.value) {
+        return;
+      }
+      const popperEl = unrefElement(popper);
+      const referenceEl = virtualReference?.value || unrefElement(reference);
+      if (!(popperEl instanceof HTMLElement)) {
+        return;
+      }
+      if (!referenceEl) {
+        return;
+      }
+      instance.value = createPopper(referenceEl, popperEl, omitBy({
+        placement,
+        strategy,
+        modifiers: [
+          {
+            name: "flip",
+            enabled: !locked
+          },
+          {
+            name: "preventOverflow",
+            options: {
+              padding: overflowPadding
+            }
+          },
+          {
+            name: "offset",
+            options: {
+              offset: [offsetSkid, offsetDistance]
+            }
+          },
+          {
+            name: "computeStyles",
+            options: {
+              adaptive,
+              gpuAcceleration
+            }
+          },
+          {
+            name: "eventListeners",
+            options: {
+              scroll,
+              resize
+            }
+          },
+          {
+            name: "sameWidth",
+            enabled: true,
+            phase: "beforeWrite",
+            requires: ["computeStyles"],
+            fn: ({ state }) => {
+              if (!state) {
+                return;
+              }
+              state.styles.popper.width = "auto";
+              state.styles.popper.minWidth = `${state.rects.reference.width}px`;
+            },
+            effect: ({ state }) => {
+              if (!state) {
+                return;
+              }
+              state.elements.popper.style.width = "auto";
+              state.elements.popper.style.minWidth = `${state.elements.reference.offsetWidth}px`;
+            }
+          }
+        ]
+      }, isUndefined));
+      onInvalidate(instance.value.destroy);
+    });
+  });
+  return [reference, popper, instance];
+}

package/dist/runtime/composables/process.d.ts

@@ -0,0 +1,4 @@
+export declare const useProcess: () => {
+    isClient: boolean | undefined;
+    isServer: boolean | undefined;
+};

package/dist/runtime/composables/process.js

@@ -0,0 +1,6 @@
+export const useProcess = () => {
+  return {
+    isClient: import.meta.client,
+    isServer: import.meta.server
+  };
+};

package/dist/runtime/composables/reset-password.d.ts

@@ -0,0 +1,14 @@
+export declare const useResetPassword: () => {
+    error: import("vue").Ref<string | null, string | null>;
+    submitting: import("vue").Ref<boolean, boolean>;
+    success: import("vue").Ref<boolean, boolean>;
+    passwords: {
+        first: string;
+        second: string;
+    };
+    inputErrors: import("vue").ComputedRef<{
+        form: string[] | undefined;
+        password: string[] | undefined;
+    } | undefined>;
+    resetPassword: () => Promise<void>;
+};