@maas/vue-equipment 0.40.0 → 1.0.0-beta.1

package/dist/plugins/MagicCookie/src/components/MagicCookieProvider.vue

@@ -0,0 +1,43 @@
+<script>
+import { defineComponent as _defineComponent } from "vue";
+import { renderSlot as _renderSlot, mergeProps as _mergeProps, createElementVNode as _createElementVNode, resolveComponent as _resolveComponent, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+import { provide } from "vue";
+import { defu } from "defu";
+import { useCookieState } from "../composables/private/useCookieState";
+import { defaultOptions } from "../utils/defaultOptions";
+import { MagicCookieInstanceId } from "../symbols";
+export default /* @__PURE__ */ _defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "MagicCookieProvider",
+  props: {
+    id: { type: null, required: true },
+    options: { type: Object, required: false }
+  },
+  setup(__props) {
+    const mappedOptions = defu(__props.options, defaultOptions);
+    const { initializeState } = useCookieState(__props.id);
+    initializeState(mappedOptions);
+    provide(MagicCookieInstanceId, __props.id);
+    return (_ctx, _cache) => {
+      const _component_client_only = _resolveComponent("client-only");
+      return _openBlock(), _createBlock(_component_client_only, null, {
+        default: _withCtx(() => [
+          _createElementVNode(
+            "div",
+            _mergeProps({ class: "magic-cookie-provider" }, _ctx.$attrs),
+            [
+              _renderSlot(_ctx.$slots, "default")
+            ],
+            16
+            /* FULL_PROPS */
+          )
+        ]),
+        _: 3
+        /* FORWARDED */
+      });
+    };
+  }
+});
+</script>

package/dist/plugins/MagicCookie/src/components/MagicCookieProvider.vue.d.ts

@@ -0,0 +1,32 @@
+import { type MaybeRef } from 'vue';
+import type { MagicCookieOptions } from '../types/index.js';
+type MagicCookieProviderProps = {
+    id: MaybeRef<string>;
+    options?: MagicCookieOptions;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCookieProviderProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCookieProviderProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/plugins/MagicCookie/src/components/MagicCookieView.vue

@@ -0,0 +1,96 @@
+<script>
+import { defineComponent as _defineComponent } from "vue";
+import { unref as _unref, renderSlot as _renderSlot, vShow as _vShow, createElementVNode as _createElementVNode, withDirectives as _withDirectives, Transition as _Transition, withCtx as _withCtx, createVNode as _createVNode, normalizeStyle as _normalizeStyle, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
+const _hoisted_1 = { class: "magic-cookie-view__inner" };
+import { inject } from "vue";
+import { AutoSize } from "@maas/vue-autosize";
+import { useCookieState } from "../composables/private/useCookieState";
+import { useCookieCallback } from "../composables/private/useCookieCallback";
+import { MagicCookieInstanceId } from "../symbols";
+import "@maas/vue-equipment/utils/css/animations/fade-in.css";
+import "@maas/vue-equipment/utils/css/animations/auto-size-out.css";
+export default /* @__PURE__ */ _defineComponent({
+  __name: "MagicCookieView",
+  setup(__props) {
+    const instanceId = inject(MagicCookieInstanceId, void 0);
+    if (!instanceId) {
+      throw new Error(
+        "MagicCookiePreferences must be used within a MagicCookieProvider"
+      );
+    }
+    const { initializeState } = useCookieState(instanceId);
+    const state = initializeState();
+    const {
+      onBeforeEnter,
+      onEnter,
+      onAfterEnter,
+      onBeforeLeave,
+      onLeave,
+      onAfterLeave
+    } = useCookieCallback(instanceId);
+    return (_ctx, _cache) => {
+      return _openBlock(), _createElementBlock(
+        "div",
+        {
+          class: "magic-cookie-view",
+          style: _normalizeStyle({ "--mc-duration": `${_unref(state).options.animation?.duration}ms` })
+        },
+        [
+          _createVNode(_unref(AutoSize), { width: false }, {
+            default: _withCtx(() => [
+              _createVNode(_Transition, {
+                name: _unref(state).options.transition,
+                onBeforeLeave: _unref(onBeforeLeave),
+                onLeave: _unref(onLeave),
+                onAfterLeave: _unref(onAfterLeave),
+                onBeforeEnter: _unref(onBeforeEnter),
+                onEnter: _unref(onEnter),
+                onAfterEnter: _unref(onAfterEnter),
+                persisted: ""
+              }, {
+                default: _withCtx(() => [
+                  _withDirectives(_createElementVNode(
+                    "div",
+                    _hoisted_1,
+                    [
+                      _renderSlot(_ctx.$slots, "default", {
+                        viewActive: _unref(state).viewActive
+                      })
+                    ],
+                    512
+                    /* NEED_PATCH */
+                  ), [
+                    [_vShow, _unref(state).viewActive]
+                  ])
+                ]),
+                _: 3
+                /* FORWARDED */
+              }, 8, ["name", "onBeforeLeave", "onLeave", "onAfterLeave", "onBeforeEnter", "onEnter", "onAfterEnter"])
+            ]),
+            _: 3
+            /* FORWARDED */
+          })
+        ],
+        4
+        /* STYLE */
+      );
+    };
+  }
+});
+</script>
+
+<style>
+.magic-cookie-view {
+  width: 100%;
+  clip-path: var(--magic-cookie-view-clip-path, inset(0));
+}
+
+.magic-cookie-view-enter-active {
+  position: relative;
+  animation: fade-in var(--mc-duration) var(--ease-in-out);
+}
+
+.magic-cookie-view-leave-active {
+  animation: auto-size-out var(--mc-duration) var(--ease-in-out);
+}
+</style>

package/dist/plugins/{MagicCommand/src/components/MagicCommandHead.vue.d.ts → MagicCookie/src/components/MagicCookieView.vue.d.ts}

@@ -1,13 +1,17 @@
+import '@maas/vue-equipment/utils/css/animations/fade-in.css';
+import '@maas/vue-equipment/utils/css/animations/auto-size-out.css';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
-        default?(_: {}): any;
+        default?(_: {
+            viewActive: boolean;
+        }): any;
     };
     refs: {};
     rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/plugins/MagicCookie/src/composables/private/useCookieCallback.d.ts

@@ -0,0 +1,9 @@
+import { type MaybeRef } from 'vue';
+export declare function useCookieCallback(instanceId: MaybeRef<string>): {
+    onBeforeEnter: () => void;
+    onEnter: () => void;
+    onAfterEnter: () => Promise<void>;
+    onBeforeLeave: () => void;
+    onLeave: () => void;
+    onAfterLeave: () => void;
+};

package/dist/plugins/MagicCookie/src/composables/private/useCookieCallback.mjs

@@ -0,0 +1,31 @@
+import { toValue } from "vue";
+import { useMagicEmitter } from "@maas/vue-equipment/plugins";
+export function useCookieCallback(instanceId) {
+  const emitter = useMagicEmitter();
+  function onBeforeEnter() {
+    emitter.emit("beforeEnter", toValue(instanceId));
+  }
+  function onEnter() {
+    emitter.emit("enter", toValue(instanceId));
+  }
+  async function onAfterEnter() {
+    emitter.emit("afterEnter", toValue(instanceId));
+  }
+  function onBeforeLeave() {
+    emitter.emit("beforeLeave", toValue(instanceId));
+  }
+  function onLeave() {
+    emitter.emit("leave", toValue(instanceId));
+  }
+  function onAfterLeave() {
+    emitter.emit("afterLeave", toValue(instanceId));
+  }
+  return {
+    onBeforeEnter,
+    onEnter,
+    onAfterEnter,
+    onBeforeLeave,
+    onLeave,
+    onAfterLeave
+  };
+}

package/dist/plugins/MagicCookie/src/composables/private/useCookieItem.d.ts

@@ -0,0 +1,16 @@
+import { type MaybeRef } from 'vue';
+import type { CookieItem } from '../../types/index.js';
+type UseCookieItemArgs = {
+    instanceId: MaybeRef<string>;
+};
+type InitializeItemArgs = Omit<CookieItem, 'active'>;
+export declare function useCookieItem(args: UseCookieItemArgs): {
+    initializeItem: (args: InitializeItemArgs) => CookieItem;
+    deleteItem: (id: string) => void;
+    getItem: (id: string) => CookieItem | undefined;
+    selectItem: (id: string, timestamp?: number) => void;
+    unselectItem: (id: string, timestamp?: number) => void;
+    toggleItem: (id: string) => void;
+    setItemCookie: (id: string) => void;
+};
+export {};

package/dist/plugins/MagicCookie/src/composables/private/useCookieItem.mjs

@@ -0,0 +1,87 @@
+import { reactive, toValue } from "vue";
+import { useCookies } from "@vueuse/integrations/useCookies";
+import { useCookieState } from "./useCookieState.mjs";
+export function useCookieItem(args) {
+  const { instanceId } = args;
+  const { initializeState } = useCookieState(instanceId);
+  const state = initializeState();
+  function getBrowserCookie(id) {
+    const universalCookies = useCookies([id]);
+    return universalCookies.get(id);
+  }
+  function createItem(args2) {
+    const { id, optional, maxAge = state.options.maxAge } = args2;
+    const storedValue = getBrowserCookie(id);
+    const mappedActive = storedValue ?? (optional === false ? true : false);
+    const mappedOptional = optional ?? true;
+    const timestamp = (/* @__PURE__ */ new Date()).getTime();
+    const item = {
+      id,
+      active: mappedActive,
+      optional: mappedOptional,
+      timestamp,
+      maxAge
+    };
+    console.log(item);
+    return reactive(item);
+  }
+  function addItem(args2) {
+    const item = createItem(args2);
+    state.items.push(item);
+    return item;
+  }
+  function initializeItem(args2) {
+    const { id } = args2;
+    const item = getItem(id) ?? addItem(args2);
+    return item;
+  }
+  function deleteItem(id) {
+    if (!state?.items) return;
+    state.items = state.items.filter((x) => x.id !== id);
+  }
+  function getItem(id) {
+    return state?.items.find((item) => {
+      return item.id === id;
+    });
+  }
+  function selectItem(id, timestamp) {
+    const item = getItem(id);
+    if (item) {
+      item.active = true;
+      item.timestamp = timestamp ?? item.timestamp;
+    }
+  }
+  function unselectItem(id, timestamp) {
+    const item = getItem(id);
+    if (item) {
+      item.active = false;
+      item.timestamp = timestamp ?? item.timestamp;
+    }
+  }
+  function toggleItem(id) {
+    const item = getItem(id);
+    if (item) {
+      item.active = !item.active;
+    }
+  }
+  function setItemCookie(id) {
+    const item = getItem(id);
+    if (!item) {
+      console.warn(`Item ${id} not found. Cookie cannot be set.`);
+      return;
+    }
+    useCookies([id]).set(toValue(id), item.active, {
+      path: "/",
+      maxAge: item.maxAge
+    });
+  }
+  return {
+    initializeItem,
+    deleteItem,
+    getItem,
+    selectItem,
+    unselectItem,
+    toggleItem,
+    setItemCookie
+  };
+}

package/dist/plugins/MagicCookie/src/composables/private/useCookieState.d.ts

@@ -0,0 +1,7 @@
+import { type Ref, type MaybeRef } from 'vue';
+import type { CookieState, MagicCookieOptions } from '../../types/index.js';
+export declare function useCookieState(instanceId: MaybeRef<string>): {
+    initializeState: (options?: MagicCookieOptions) => CookieState;
+    deleteState: () => void;
+    cookieStateStore: Ref<CookieState[], CookieState[]>;
+};

package/dist/plugins/MagicCookie/src/composables/private/useCookieState.mjs

@@ -0,0 +1,43 @@
+import { ref, reactive, toValue } from "vue";
+import { defu } from "defu";
+import { defaultOptions } from "../../utils/defaultOptions.mjs";
+const cookieStateStore = ref([]);
+export function useCookieState(instanceId) {
+  function createState(id) {
+    const state = {
+      id,
+      items: [],
+      options: { ...defaultOptions },
+      viewActive: false
+    };
+    return reactive(state);
+  }
+  function addState(id) {
+    const state = createState(id);
+    cookieStateStore.value = [...cookieStateStore.value, state];
+    return state;
+  }
+  function initializeState(options) {
+    let state = cookieStateStore.value.find((entry) => {
+      return entry.id === toValue(instanceId);
+    });
+    if (!state) {
+      state = addState(toValue(instanceId));
+    }
+    if (options) {
+      const mappedOptions = defu(options, defaultOptions);
+      state.options = mappedOptions;
+    }
+    return state;
+  }
+  function deleteState() {
+    cookieStateStore.value = cookieStateStore.value.filter(
+      (x) => x.id !== toValue(instanceId)
+    );
+  }
+  return {
+    initializeState,
+    deleteState,
+    cookieStateStore
+  };
+}

package/dist/plugins/MagicCookie/src/composables/useMagicCookie.d.ts

@@ -1,18 +1,18 @@
-import type { MagicCookieConsent } from '../types/index.js';
-export declare function useMagicCookie(): {
-    preferencesVisible: import("vue").Ref<boolean, boolean>;
-    selectedCookies: import("vue").Ref<{
-        [key: string]: boolean;
-    }, {
-        [key: string]: boolean;
-    }>;
-    cookieConsent: import("vue").WritableComputedRef<MagicCookieConsent, MagicCookieConsent>;
-    toggleSelection: (key: string) => void;
-    accept: () => void;
+import { type MaybeRef } from 'vue';
+import type { CookieConsent, MagicCookieCallbackArgs } from '../types/index.js';
+export declare function useMagicCookie(id: MaybeRef<string>): {
+    showView: () => void;
+    hideView: () => void;
+    toggleView: () => void;
+    cookieConsent: import("vue").ComputedRef<CookieConsent>;
+    selectItem: (id: string, timestamp?: number) => void;
+    unselectItem: (id: string, timestamp?: number) => void;
+    toggleItem: (id: string) => void;
+    acceptAll: () => Promise<void>;
     acceptSelected: () => void;
-    reject: () => void;
-    onAccept: (handler: (args: MagicCookieConsent) => void) => void;
-    onAcceptSelected: (handler: (args: MagicCookieConsent) => void) => void;
-    onReject: (handler: (args: MagicCookieConsent) => void) => void;
+    rejectAll: () => Promise<void>;
+    onAccept: (callback: (args: MagicCookieCallbackArgs) => void) => void;
+    onAcceptSelected: (callback: (args: MagicCookieCallbackArgs) => void) => void;
+    onReject: (callback: (args: MagicCookieCallbackArgs) => void) => void;
 };
 export type UseMagicCookieReturn = ReturnType<typeof useMagicCookie>;

package/dist/plugins/MagicCookie/src/composables/useMagicCookie.mjs

@@ -1,79 +1,78 @@
-import { computed, ref } from "vue";
-import { useCookies } from "@vueuse/integrations/useCookies";
-import { toValue } from "@vueuse/core";
+import { computed, nextTick } from "vue";
 import { useMagicEmitter } from "@maas/vue-equipment/plugins";
-import { cookieApiStore } from "./private/useCookieApi.mjs";
-const preferencesVisible = ref(false);
-const selectedCookies = ref({});
-export function useMagicCookie() {
-  const universalCookies = useCookies(["cookie_consent"]);
-  const cookieConsent = computed({
-    get: () => {
-      return universalCookies.get("cookie_consent");
-    },
-    set: (value) => {
-      universalCookies.set("cookie_consent", value, {
-        path: "/",
-        maxAge: cookieApiStore.value?.maxAge
-      });
-    }
-  });
+import { useCookieState } from "./private/useCookieState.mjs";
+import { useCookieItem } from "./private/useCookieItem.mjs";
+export function useMagicCookie(id) {
+  const { selectItem, unselectItem, toggleItem, setItemCookie } = useCookieItem(
+    { instanceId: id }
+  );
   const emitter = useMagicEmitter();
-  selectedCookies.value = cookieConsent.value?.cookies || {};
-  function toggleSelection(key) {
-    selectedCookies.value = {
-      ...selectedCookies.value,
-      [key]: !selectedCookies.value[key]
-    };
+  const { initializeState } = useCookieState(id);
+  const state = initializeState();
+  const cookieConsent = computed(
+    () => state?.items.reduce(
+      (acc, cookie) => ({
+        ...acc,
+        [cookie.id]: cookie.optional === false ? true : cookie.active
+      }),
+      {}
+    )
+  );
+  function showView() {
+    state.viewActive = true;
+  }
+  function hideView() {
+    state.viewActive = false;
   }
-  function accept() {
-    const cookies = cookieApiStore.value?.cookies?.reduce((result, cookie) => {
-      result[cookie.key] = true;
-      return result;
-    }, {});
-    selectedCookies.value = cookies;
+  function toggleView() {
+    state.viewActive = !state.viewActive;
+  }
+  async function acceptAll() {
     const timestamp = (/* @__PURE__ */ new Date()).getTime();
-    cookieConsent.value = { timestamp, cookies };
-    emitter.emit("accept", cookieConsent.value);
+    for (const cookie of state.items) {
+      selectItem(cookie.id, timestamp);
+      setItemCookie(cookie.id);
+    }
+    await nextTick();
+    emitter.emit("acceptAll", cookieConsent.value);
   }
   function acceptSelected() {
-    const timestamp = (/* @__PURE__ */ new Date()).getTime();
-    cookieConsent.value = {
-      timestamp,
-      cookies: selectedCookies.value
-    };
+    for (const cookie of state.items) {
+      setItemCookie(cookie.id);
+    }
     emitter.emit("acceptSelected", cookieConsent.value);
   }
-  function reject() {
-    const cookies = cookieApiStore.value?.cookies?.reduce((result, cookie) => {
-      result[cookie.key] = cookie.optional === false ? true : false;
-      return result;
-    }, {});
-    selectedCookies.value = cookies;
+  async function rejectAll() {
     const timestamp = (/* @__PURE__ */ new Date()).getTime();
-    cookieConsent.value = { timestamp, cookies };
-    emitter.emit("reject", cookieConsent.value);
+    for (const cookie of state.items) {
+      if (cookie.optional !== false) {
+        unselectItem(cookie.id, timestamp);
+      }
+      setItemCookie(cookie.id);
+    }
+    await nextTick();
+    emitter.emit("rejectAll", cookieConsent.value);
   }
-  function onAccept(handler) {
-    emitter.on("accept", (args) => handler(toValue(args)));
+  function onAccept(callback) {
+    emitter.on("acceptAll", callback);
   }
-  function onAcceptSelected(handler) {
-    emitter.on(
-      "acceptSelected",
-      (args) => handler(toValue(args))
-    );
+  function onAcceptSelected(callback) {
+    emitter.on("acceptSelected", callback);
   }
-  function onReject(handler) {
-    emitter.on("reject", (args) => handler(toValue(args)));
+  function onReject(callback) {
+    emitter.on("rejectAll", callback);
   }
   return {
-    preferencesVisible,
-    selectedCookies,
+    showView,
+    hideView,
+    toggleView,
     cookieConsent,
-    toggleSelection,
-    accept,
+    selectItem,
+    unselectItem,
+    toggleItem,
+    acceptAll,
     acceptSelected,
-    reject,
+    rejectAll,
     onAccept,
     onAcceptSelected,
     onReject

package/dist/plugins/MagicCookie/src/symbols/index.d.ts

@@ -0,0 +1,5 @@
+import type { InjectionKey, MaybeRef } from 'vue';
+declare const MagicCookieInstanceId: InjectionKey<MaybeRef<string>>;
+declare const MagicCookieItemId: InjectionKey<string>;
+declare const MagicCookieItemActive: InjectionKey<MaybeRef<boolean>>;
+export { MagicCookieInstanceId, MagicCookieItemId, MagicCookieItemActive };

package/dist/plugins/MagicCookie/src/symbols/index.mjs

@@ -0,0 +1,4 @@
+const MagicCookieInstanceId = Symbol();
+const MagicCookieItemId = Symbol();
+const MagicCookieItemActive = Symbol();
+export { MagicCookieInstanceId, MagicCookieItemId, MagicCookieItemActive };

package/dist/plugins/MagicCookie/src/types/index.d.ts

@@ -1,16 +1,34 @@
-export type MagicCookieRecord = {
-    key: string;
+export interface CookieItem {
+    id: string;
+    active: boolean;
     optional?: boolean;
-    title?: string;
-    text?: string;
-    [key: string]: unknown;
-};
-export type MagicCookieConsent = {
-    timestamp: number | undefined;
-    cookies: Record<string, boolean>;
-};
+    maxAge?: number;
+    timestamp?: number;
+}
+export interface CookieState {
+    id: string;
+    options: MagicCookieOptions;
+    items: CookieItem[];
+    viewActive: boolean;
+}
+export type CookieConsent = Record<CookieItem['id'], CookieItem['active']>;
+export interface MagicCookieOptions {
+    maxAge?: number;
+    transition?: string;
+    animation?: {
+        duration: number;
+        easing: (t: number) => number;
+    };
+}
 export type CookieEvents = {
-    accept: MagicCookieConsent;
-    reject: MagicCookieConsent;
-    acceptSelected: MagicCookieConsent;
+    beforeEnter: string;
+    enter: string;
+    afterEnter: string;
+    beforeLeave: string;
+    leave: string;
+    afterLeave: string;
+    acceptAll: CookieConsent;
+    rejectAll: CookieConsent;
+    acceptSelected: CookieConsent;
 };
+export type MagicCookieCallbackArgs = CookieConsent;

package/dist/plugins/MagicCookie/src/utils/defaultOptions.d.ts

@@ -0,0 +1,4 @@
+import type { MagicCookieOptions } from '../types/index.js';
+import { type RequireAll } from '@maas/vue-equipment/utils';
+declare const defaultOptions: RequireAll<MagicCookieOptions>;
+export { defaultOptions };

package/dist/plugins/MagicCookie/src/utils/defaultOptions.mjs

@@ -0,0 +1,10 @@
+import { easeOutQuad } from "@maas/vue-equipment/utils";
+const defaultOptions = {
+  maxAge: 24 * 60 * 60 * 60,
+  transition: "magic-cookie-view",
+  animation: {
+    duration: 300,
+    easing: easeOutQuad
+  }
+};
+export { defaultOptions };