@open-xamu-co/firebase-nuxt 1.0.0 → 1.1.0

package/dist/runtime/functions/utils/event.d.ts

@@ -0,0 +1,71 @@
+import type { QueryDocumentSnapshot } from "firebase-admin/firestore";
+import { type Request } from "firebase-functions/tasks";
+import type { tLogger } from "@open-xamu-co/ui-common-types";
+import type { SharedData } from "../types/entities/instance.js";
+interface OnCreatedOptions<T extends SharedData> {
+    /**
+     * Fields to exclude from the new document
+     */
+    exclude?: (keyof T)[];
+    /**
+     * Default values when not provided
+     */
+    defaults?: Partial<T>;
+}
+/**
+ * Adds timestamps
+ *
+ * If the callback throws an error the document will be deleted
+ *
+ * @param collectionPath target collection (collection/optionalsubcollection)
+ * @param callback optional callback fn
+ * @returns firebase function
+ */
+export declare function onCreated<T extends SharedData>(collectionPath: string, callback?: (newDoc: QueryDocumentSnapshot<T>, utils: {
+    createdAt: Date;
+    logger: tLogger;
+}) => Partial<T> | undefined | void | Promise<Partial<T> | undefined | void>, { defaults, exclude }?: OnCreatedOptions<T>): import("firebase-functions/core").CloudFunction<import("firebase-functions/v2/firestore").FirestoreEvent<import("firebase-functions/v2/firestore").QueryDocumentSnapshot | undefined, Record<string, string>>>;
+interface OnUpdatedOptions<T extends SharedData> {
+    /**
+     * Default values when not provided
+     */
+    defaults?: Partial<T>;
+}
+/**
+ * Updates timestamp
+ *
+ * @param collectionPath target collection (collection/optionalsubcollection)
+ * @param callback optional callback fn
+ * @returns firebase function
+ */
+export declare function onUpdated<T extends SharedData>(collectionPath: string, callback?: (newDoc: QueryDocumentSnapshot<T>, oldDoc: QueryDocumentSnapshot<T>, utils: {
+    updatedAt: Date;
+    logger: tLogger;
+}) => Partial<T> | undefined | void | Promise<Partial<T> | undefined | void>, { defaults }?: OnUpdatedOptions<T>): import("firebase-functions/core").CloudFunction<import("firebase-functions/v2/firestore").FirestoreEvent<import("firebase-functions/v1").Change<import("firebase-functions/v2/firestore").QueryDocumentSnapshot> | undefined, Record<string, string>>>;
+/**
+ * Runs callback after document has been removed
+ *
+ * @param collectionPath target collection (collection/optionalsubcollection)
+ * @param callback callback fn
+ * @returns firebase function
+ */
+export declare function onDelete<T extends SharedData>(collectionPath: string, callback: (deletedDoc: QueryDocumentSnapshot<T>, utils: {
+    deletedAt: Date;
+    logger: tLogger;
+}) => void): import("firebase-functions/core").CloudFunction<import("firebase-functions/v2/firestore").FirestoreEvent<import("firebase-functions/v2/firestore").QueryDocumentSnapshot | undefined, Record<string, string>>>;
+/**
+ * Runs callback at given schedule
+ *
+ * @param schedule The schedule in Unix Crontab or AppEngine syntax
+ * @param callback callback fn
+ * @returns firebase function
+ */
+export declare function onSchedule(schedule: string, callback: () => Promise<void> | void): import("firebase-functions/v2/scheduler").ScheduleFunction;
+/**
+ * Runs callback at task dispatch
+ *
+ * @param callback callback fn
+ * @returns firebase function
+ */
+export declare function onDispatch<T extends Record<string, any>>(callback: (request: Request<T>) => Promise<void> | void): import("firebase-functions/tasks").TaskQueueFunction<T>;
+export {};

package/dist/runtime/functions/utils/event.js

@@ -0,0 +1,91 @@
+import { omit } from "lodash-es";
+import {
+  onDocumentDeleted,
+  onDocumentCreated,
+  onDocumentUpdated
+} from "firebase-functions/v2/firestore";
+import { onSchedule as onScheduleV2 } from "firebase-functions/v2/scheduler";
+import { onTaskDispatched } from "firebase-functions/tasks";
+import { getFirebase } from "./firebase.js";
+import { makeFunctionsLogger } from "./logger.js";
+function getDocumentPath(collectionPath) {
+  const [collection, ...subCollections] = collectionPath.split("/");
+  const initialPath = `${collection}/{documentId}`;
+  return subCollections.reduce((acc, current, currentIndex) => {
+    return `${acc}/${current}/{document${currentIndex + 1}Id}`;
+  }, initialPath);
+}
+export function onCreated(collectionPath, callback, { defaults = {}, exclude = [] } = {}) {
+  const document = getDocumentPath(collectionPath);
+  return onDocumentCreated({ document, region: "us-east1" }, async ({ data, ...metadata }) => {
+    const { firebaseFirestore } = getFirebase(`onCreated: "${document}"`);
+    const createdAt = /* @__PURE__ */ new Date();
+    const newDoc = data;
+    if (!newDoc) return null;
+    const newDocData = newDoc.data() || {};
+    const { createdByRef } = newDocData;
+    const at = createdByRef?.parent.parent || firebaseFirestore;
+    const logger = makeFunctionsLogger(at, createdByRef, metadata);
+    try {
+      const callbackData = await callback?.(newDoc, { createdAt, logger });
+      return newDoc.ref.set(
+        {
+          ...defaults,
+          ...omit(newDocData, exclude),
+          ...callbackData,
+          createdAt,
+          updatedAt: createdAt
+        },
+        { merge: true }
+      );
+    } catch (err) {
+      return newDoc.ref.delete();
+    }
+  });
+}
+export function onUpdated(collectionPath, callback, { defaults = {} } = {}) {
+  const document = getDocumentPath(collectionPath);
+  return onDocumentUpdated({ document, region: "us-east1" }, async ({ data, ...metadata }) => {
+    const { firebaseFirestore } = getFirebase(`onUpdated: "${document}"`);
+    const updatedAt = /* @__PURE__ */ new Date();
+    const newDoc = data?.after;
+    const oldDoc = data?.before;
+    if (!newDoc || !oldDoc) return null;
+    const { updatedAt: oldUpdatedAt, updatedByRef, deletedByRef, lock } = newDoc.data();
+    const { updatedAt: newUpdatedAt } = oldDoc.data();
+    const at = updatedByRef?.parent.parent || firebaseFirestore;
+    const logger = makeFunctionsLogger(at, updatedByRef, metadata);
+    if (deletedByRef && (!lock || Array.isArray(lock) && !lock.length)) {
+      return newDoc.ref.delete();
+    }
+    if (!oldUpdatedAt || !newUpdatedAt || !newUpdatedAt.isEqual(oldUpdatedAt)) return null;
+    const callbackData = await callback?.(newDoc, oldDoc, { updatedAt, logger });
+    return newDoc.ref.set({ ...defaults, ...callbackData, updatedAt }, { merge: true });
+  });
+}
+export function onDelete(collectionPath, callback) {
+  const document = getDocumentPath(collectionPath);
+  return onDocumentDeleted({ document, region: "us-east1" }, async ({ data, ...metadata }) => {
+    const { firebaseFirestore } = getFirebase(`onDeleted: "${document}"`);
+    const deletedAt = /* @__PURE__ */ new Date();
+    const deletedDoc = data;
+    const { deletedByRef } = deletedDoc?.data() || {};
+    const at = deletedByRef?.parent.parent || firebaseFirestore;
+    const logger = makeFunctionsLogger(at, deletedByRef, metadata);
+    if (!deletedDoc) return null;
+    return callback(deletedDoc, { deletedAt, logger });
+  });
+}
+export function onSchedule(schedule, callback) {
+  return onScheduleV2({ schedule, region: "us-east1", timeZone: "America/Bogota" }, callback);
+}
+export function onDispatch(callback) {
+  return onTaskDispatched(
+    {
+      retryConfig: { maxAttempts: 2, minBackoffSeconds: 60 },
+      rateLimits: { maxConcurrentDispatches: 100 },
+      region: "us-east1"
+    },
+    callback
+  );
+}

package/dist/runtime/functions/utils/firebase.d.ts

@@ -0,0 +1,7 @@
+import { type AppOptions } from "firebase-admin/app";
+export declare function getFirebase(at?: string, appOptions?: AppOptions): {
+    firebaseApp: import("firebase-admin/app").App;
+    firebaseFirestore: FirebaseFirestore.Firestore;
+    firebaseAuth: import("firebase-admin/auth").Auth;
+    firebaseStorage: import("firebase-admin/storage").Storage;
+};

package/dist/runtime/functions/utils/firebase.js

@@ -0,0 +1,21 @@
+import { getApp, getApps, initializeApp } from "firebase-admin/app";
+import { getAuth } from "firebase-admin/auth";
+import { getFirestore } from "firebase-admin/firestore";
+import { getStorage } from "firebase-admin/storage";
+export function getFirebase(at = "Unknown", appOptions) {
+  if (import.meta.client) throw new Error("This function is only available in server context");
+  try {
+    const firebaseApp = getApps().length ? getApp() : initializeApp(appOptions);
+    const firebaseFirestore = getFirestore(firebaseApp);
+    const firebaseAuth = getAuth(firebaseApp);
+    const firebaseStorage = getStorage();
+    if (!("ignoreUndefined" in global)) {
+      firebaseFirestore.settings({ ignoreUndefinedProperties: true });
+      Object.assign(global, { ignoreUndefined: true });
+    }
+    return { firebaseApp, firebaseFirestore, firebaseAuth, firebaseStorage };
+  } catch (err) {
+    console.log(err);
+    throw new Error(`Could not initialize Firebase Admin SDK, ${err.message}, at: ${at}`);
+  }
+}

package/dist/runtime/functions/utils/logger.d.ts

@@ -0,0 +1,3 @@
+import { DocumentReference, type Firestore } from "firebase-admin/firestore";
+import type { tLogger } from "@open-xamu-co/ui-common-types";
+export declare function makeFunctionsLogger(at: DocumentReference | Firestore, authorRef?: DocumentReference, metadata?: Record<string, any>): tLogger;

package/dist/runtime/functions/utils/logger.js

@@ -0,0 +1,17 @@
+import { DocumentReference } from "firebase-admin/firestore";
+import { getLog } from "./logs.js";
+export function makeFunctionsLogger(at, authorRef, metadata = {}) {
+  return function(...args) {
+    const logData = getLog(...args, metadata);
+    if (!logData) return;
+    try {
+      const logsRef = at.collection("logs");
+      if (at instanceof DocumentReference && authorRef) {
+        logData.createdByRef = logData.updatedByRef = authorRef;
+      }
+      logsRef.add(logData);
+    } catch (err) {
+      console.error("Error logging to db", err);
+    }
+  };
+}

package/dist/runtime/functions/utils/logs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AVOID NODE IMPORTS ON THIS FILE
+ */
+import type { tLogger } from "@open-xamu-co/ui-common-types";
+import type { LogData } from "../types/entities/logs.js";
+/**
+ * Log to the db for later analysis
+ * TODO: Bypass some firebase error codes from being logged
+ */
+export declare const getLog: (...args: Parameters<tLogger>) => LogData;

package/dist/runtime/functions/utils/logs.js

@@ -0,0 +1,47 @@
+function getFirebaseError(error) {
+  const isFirebaseError = typeof error === "object" && !!error && "code" in error;
+  if (isFirebaseError) return error;
+}
+export const getLog = (...args) => {
+  const [at, errorOrMessage, ...errorOrMetadata] = args;
+  const logData = { at };
+  let firebaseError;
+  if (typeof errorOrMessage === "string") {
+    const [error, ...metadata] = errorOrMetadata;
+    logData.message = errorOrMessage;
+    logData.metadata = metadata;
+    firebaseError = getFirebaseError(error);
+    if (firebaseError) {
+      logData.code = firebaseError.code;
+      logData.error = JSON.stringify(firebaseError);
+    } else if (error instanceof Error) {
+      logData.error = error.toString();
+    }
+  } else {
+    const [...metadata] = errorOrMetadata;
+    logData.metadata = metadata;
+    firebaseError = getFirebaseError(errorOrMessage);
+    if (firebaseError) {
+      logData.message = firebaseError.message;
+      logData.code = firebaseError.code;
+      logData.error = JSON.stringify(firebaseError);
+    } else if (errorOrMessage instanceof Error) {
+      logData.message = errorOrMessage.message;
+      logData.error = errorOrMessage.toString();
+    }
+  }
+  if (Array.isArray(logData.metadata)) {
+    if (logData.metadata.length <= 1) logData.metadata = logData.metadata[0] || "";
+    else {
+      const metadata = {};
+      for (let i = 0; i < logData.metadata.length; i++) {
+        const item = logData.metadata[i];
+        if (typeof item === "object") Object.assign(metadata, item);
+        else metadata[`metadata${i}`] = item;
+      }
+      logData.metadata = metadata;
+    }
+  }
+  console.warn(logData.message);
+  return logData;
+};

package/dist/runtime/functions/utils/price.d.ts

@@ -0,0 +1,12 @@
+import type { PriceData } from "../types/entities/base.js";
+export interface iPriceProps extends Pick<PriceData, "price" | "base" | "iva"> {
+    quantity?: number;
+}
+export declare function makeUsePrice(tax: number, currency?: string): ({ price, base, iva, quantity }?: iPriceProps) => {
+    iva: number;
+    base: number;
+    price: number;
+    formattedIva: string;
+    formattedBase: string;
+    formattedPrice: string;
+};

package/dist/runtime/functions/utils/price.js

@@ -0,0 +1,26 @@
+export function makeUsePrice(tax, currency = "COP") {
+  const CURRENCY = new Intl.NumberFormat("es-CO", {
+    style: "currency",
+    currency
+  });
+  return function({ price = 0, base = 0, iva = 0, quantity = 1 } = {}) {
+    base ||= price / tax;
+    iva ||= price - base;
+    function format(value, free) {
+      const formatted = `${CURRENCY.format(value)} ${currency.toLowerCase()}`;
+      if (value) return formatted;
+      return free ? "Gratis" : formatted;
+    }
+    const multipliedIva = iva * quantity;
+    const multipliedBase = base * quantity;
+    const multipliedPrice = price * quantity;
+    return {
+      iva: multipliedIva,
+      base: multipliedBase,
+      price: multipliedPrice,
+      formattedIva: format(multipliedIva),
+      formattedBase: format(multipliedBase),
+      formattedPrice: format(multipliedPrice, true)
+    };
+  };
+}

package/dist/runtime/functions/utils/queue.d.ts

@@ -0,0 +1,4 @@
+export declare function getQueueUrl(name: string): Promise<{
+    projectId: string;
+    uri: any;
+}>;

package/dist/runtime/functions/utils/queue.js

@@ -0,0 +1,11 @@
+import { GoogleAuth } from "google-auth-library";
+export async function getQueueUrl(name) {
+  const auth = new GoogleAuth({ scopes: "https://www.googleapis.com/auth/cloud-platform" });
+  const projectId = await auth.getProjectId();
+  const url = `https://cloudfunctions.googleapis.com/v2beta/projects/${projectId}/locations/us-east1/functions/${name}`;
+  const client = await auth.getClient();
+  const res = await client.request({ url });
+  const uri = res.data?.serviceConfig?.uri;
+  if (!uri) throw new Error(`Unable to retreive uri for function at ${url}`);
+  return { projectId, uri };
+}

package/dist/runtime/functions/utils/search.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Get alphanumeric words array
+ */
+export declare function getWords(phrase: string): string[];
+/**
+ * Soundex algorithm in spanish
+ *
+ * Translated to ts by chatGPT an manually cleaned up
+ * @see https://patotech.blogspot.com/2016/04/implementacion-algoritmo-soundex-para.html
+ */
+export declare function soundexEs(phrase: string): string;
+/**
+ * Generate indexes to be used as tokens in a fuzzy search
+ */
+export declare function getSearchIndexes(phrase: string): string[];

package/dist/runtime/functions/utils/search.js

@@ -0,0 +1,38 @@
+import words from "lodash-es/words";
+import deburr from "lodash-es/deburr";
+export function getWords(phrase) {
+  return words(deburr(phrase.toUpperCase())).map((word) => word.replace(/[^a-z0-9]/gi, ""));
+}
+export function soundexEs(phrase) {
+  let tmp = phrase.replaceAll(" ", "");
+  if (!tmp) return "";
+  let firstLetter = tmp.charAt(0);
+  let rest = tmp.slice(1);
+  firstLetter = firstLetter.replace(/[V]/, "B").replace(/[ZX]/, "S").replace(/[G](?=[EI])/, "J").replace(/[C](?![HEI])/, "K");
+  tmp = firstLetter + rest;
+  tmp = tmp.replace(/CH/g, "V").replace(/QU/g, "K").replace(/LL/g, "J").replace(/CE|CI/g, "S").replace(/Y[AEIOU]/g, "J").replace(/NY|NH/g, "N");
+  firstLetter = tmp.charAt(0);
+  rest = tmp.slice(1).replace(/[AEIOUHWY]/g, "").replace(/[BPFV]/g, "1").replace(/[CGKSXZ]/g, "2").replace(/[DT]/g, "3").replace(/[L]/g, "4").replace(/[MN]/g, "5").replace(/[R]/g, "6").replace(/[QJ]/g, "7").replace(/(\d)\1+/g, "$1");
+  return (firstLetter + rest).padEnd(4, "0").slice(0, 4);
+}
+export function getSearchIndexes(phrase) {
+  const words2 = getWords(phrase);
+  const indexes = /* @__PURE__ */ new Set();
+  for (let i = 0; i < words2.length; i++) {
+    const forwardWords = words2.slice(0, words2.length - i);
+    const backwardWords = words2.slice(i);
+    [forwardWords, backwardWords].forEach((currentWords) => {
+      const perPhraseIndex = soundexEs(currentWords.join(" "));
+      const perWordIndex = currentWords.map((word) => {
+        if (word.length >= 7) {
+          const threeIndex = soundexEs(word.slice(0, 3));
+          const fiveIndex = soundexEs(word.slice(0, 5));
+          indexes.add(threeIndex).add(fiveIndex);
+        }
+        return soundexEs(word);
+      }).join(" ");
+      indexes.add(perPhraseIndex).add(perWordIndex);
+    });
+  }
+  return Array.from(indexes);
+}

package/dist/runtime/functions/utils/slugs.d.ts

@@ -0,0 +1,2 @@
+import type { DocumentReference, Firestore } from "firebase-admin/firestore";
+export declare function makeGetSlug(collectionId: string): (at: DocumentReference | Firestore, name?: string, oldSlug?: string) => Promise<string>;

package/dist/runtime/functions/utils/slugs.js

@@ -0,0 +1,16 @@
+import kebabCase from "lodash-es/kebabCase";
+export function makeGetSlug(collectionId) {
+  return async (at, name, oldSlug) => {
+    let query = at.collection(collectionId);
+    let slug = kebabCase(name);
+    if (oldSlug) query = query.where("slug", "!=", oldSlug);
+    const { docs } = await query.get();
+    const slugs = [];
+    docs.forEach((snapshot) => {
+      const blog = snapshot.data();
+      if (blog.slug) slugs.push(blog.slug);
+    });
+    if (slugs.includes(slug)) slug += slugs.length;
+    return slug;
+  };
+}

package/dist/runtime/plugins/firebase-setup.d.ts

@@ -0,0 +1,26 @@
+import { type FirebaseApp } from "firebase/app";
+import { type AppCheck } from "firebase/app-check";
+import { type Auth } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+import { makeResolveRefs } from "../client/utils/resolver.js";
+declare global {
+    interface Window {
+        FIREBASE_APPCHECK_DEBUG_TOKEN?: boolean;
+    }
+}
+export interface ClientProvide {
+    clientAppCheck: AppCheck;
+    clientFirebaseApp: FirebaseApp;
+    clientFirestore: Firestore;
+    clientAuth: Auth;
+    resolveClientRefs: ReturnType<typeof makeResolveRefs>;
+}
+/**
+ * Setup firebase client SDK
+ *
+ * 1. Provide client SDK
+ *
+ * @plugin
+ */
+declare const _default: import("nuxt/app").Plugin<Partial<ClientProvide>> & import("nuxt/app").ObjectPlugin<Partial<ClientProvide>>;
+export default _default;

package/dist/runtime/plugins/firebase-setup.js

@@ -0,0 +1,35 @@
+import { getApp, getApps, initializeApp } from "firebase/app";
+import { initializeAppCheck, ReCaptchaEnterpriseProvider } from "firebase/app-check";
+import { getAuth } from "firebase/auth";
+import { getDoc, getFirestore, initializeFirestore } from "firebase/firestore";
+import { getAnalytics } from "firebase/analytics";
+import { getPerformance } from "firebase/performance";
+import { makeResolveRefs } from "../client/utils/resolver.js";
+import { defineNuxtPlugin } from "#imports";
+export default defineNuxtPlugin({
+  name: "firebase-setup",
+  dependsOn: ["pinia"],
+  setup({ $config }) {
+    const provide = {};
+    if (import.meta.server) return { provide };
+    const { firebaseConfig, recaptchaEnterpriseKey, debugAppCheck } = $config.public;
+    if (!firebaseConfig.projectId) return { provide };
+    try {
+      provide.resolveClientRefs = makeResolveRefs(getDoc);
+      provide.clientFirebaseApp = getApps().length ? getApp() : initializeApp(firebaseConfig);
+      initializeFirestore(provide.clientFirebaseApp, { ignoreUndefinedProperties: true });
+      provide.clientFirestore = getFirestore(provide.clientFirebaseApp);
+      provide.clientAuth = getAuth(provide.clientFirebaseApp);
+      self.FIREBASE_APPCHECK_DEBUG_TOKEN = debugAppCheck;
+      provide.clientAppCheck = initializeAppCheck(provide.clientFirebaseApp, {
+        provider: new ReCaptchaEnterpriseProvider(recaptchaEnterpriseKey),
+        isTokenAutoRefreshEnabled: true
+      });
+      getAnalytics(provide.clientFirebaseApp);
+      getPerformance(provide.clientFirebaseApp);
+    } catch (err) {
+      console.error("Firebase Setup Error", err);
+    }
+    return { provide };
+  }
+});

package/dist/runtime/plugins/loaded.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/loaded.client.js

@@ -0,0 +1,44 @@
+import { eMQ } from "@open-xamu-co/ui-common-enums";
+import { defineNuxtPlugin, useAppStore } from "#imports";
+export default defineNuxtPlugin({
+  name: "loaded",
+  dependsOn: ["pinia", "firebase-setup"],
+  parallel: true,
+  setup: ({ hook }) => {
+    hook("app:mounted", () => {
+      document.body.classList.add("is--loaded");
+      if (import.meta.server) return;
+      const APP = useAppStore();
+      function tvMQHandler(e) {
+        APP.setTvMQRange(e.matches);
+      }
+      function laptopMQHandler(e) {
+        APP.setLaptopMQRange(e.matches);
+      }
+      function tabletMQHandler(e) {
+        APP.setTabletMQRange(e.matches);
+      }
+      function mobileMQHandler(e) {
+        APP.setMobileMQRange(e.matches);
+      }
+      function smartwatchMQHandler(e) {
+        APP.setSmartwatchMQRange(e.matches);
+      }
+      const tvMQList = window.matchMedia(eMQ.TV);
+      const laptopMQList = window.matchMedia(eMQ.LAPTOP);
+      const tabletMQList = window.matchMedia(eMQ.TABLET);
+      const mobileMQList = window.matchMedia(eMQ.MOBILE);
+      const smartwatchMQList = window.matchMedia(eMQ.SMARTWATCH);
+      APP.setTvMQRange(tvMQList.matches);
+      APP.setLaptopMQRange(laptopMQList.matches);
+      APP.setTabletMQRange(tabletMQList.matches);
+      APP.setMobileMQRange(mobileMQList.matches);
+      APP.setSmartwatchMQRange(smartwatchMQList.matches);
+      tvMQList.addEventListener("change", tvMQHandler, true);
+      laptopMQList.addEventListener("change", laptopMQHandler, true);
+      tabletMQList.addEventListener("change", tabletMQHandler, true);
+      mobileMQList.addEventListener("change", mobileMQHandler, true);
+      smartwatchMQList.addEventListener("change", smartwatchMQHandler, true);
+    });
+  }
+});

package/dist/runtime/plugins/scrollBehavior.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/scrollBehavior.client.js

@@ -0,0 +1,20 @@
+import { createRouterScroller } from "vue-router-better-scroller";
+import { defineNuxtPlugin } from "#imports";
+function scrollHandler({ savedPosition }) {
+  return savedPosition || { top: 0, left: 0, behavior: "smooth" };
+}
+export default defineNuxtPlugin({
+  name: "scrollBehavior",
+  parallel: true,
+  setup: ({ vueApp }) => {
+    vueApp.use(
+      createRouterScroller({
+        selectors: {
+          window: scrollHandler,
+          body: scrollHandler,
+          ".scrollable": scrollHandler
+        }
+      })
+    );
+  }
+});

package/dist/runtime/providers/firebase.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderGetImage } from "@nuxt/image";
+export declare const getImage: ProviderGetImage;

package/dist/runtime/providers/firebase.js

@@ -0,0 +1,7 @@
+export const getImage = (url) => {
+  if (url.startsWith("/firebase/")) {
+    url = `/api/media/images/${url.substring(10)}`;
+    return { url };
+  }
+  return { url };
+};

package/dist/runtime/public/js/file-upload.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/public/js/file-upload.js

@@ -0,0 +1,67 @@
+import {
+	initializeApp,
+	getApps,
+	getApp,
+} from "https://www.gstatic.com/firebasejs/12.6.0/firebase-app.js";
+import {
+	getAuth,
+	onAuthStateChanged,
+} from "https://www.gstatic.com/firebasejs/12.6.0/firebase-auth.js";
+import {
+	initializeAppCheck,
+	CustomProvider,
+} from "https://www.gstatic.com/firebasejs/12.6.0/firebase-app-check.js";
+import {
+	getStorage,
+	uploadBytes,
+	ref as storageRef,
+} from "https://www.gstatic.com/firebasejs/12.6.0/firebase-storage.js";
+
+// Worker for image uploading to firebase storage
+self.onmessage = async ({ data }) => {
+	const { filePath, file, customMetadata, appData, appCheckToken: token } = data;
+
+	try {
+		// Get app
+		const app = getApps().length ? getApp() : initializeApp(appData);
+		// Set auth, required by fire storage custom rule
+		const appAuth = getAuth(app);
+
+		/**
+		 * Initialize AppCheck
+		 * @see https://github.com/firebase/firebase-js-sdk/issues/6645#issuecomment-1316654203
+		 */
+		initializeAppCheck(app, {
+			provider: new CustomProvider({
+				getToken: () => Promise.resolve({ token, expireTimeMillis: 0 }),
+			}),
+		});
+
+		// Check auth
+		const unsub = onAuthStateChanged(appAuth, async (authUser) => {
+			// Auth required for uploading
+			if (!authUser) return self.postMessage({ message: "Missing auth", type: "message" });
+
+			// Setup storage
+			const storage = getStorage(app);
+			const fileRef = storageRef(storage, filePath);
+
+			try {
+				// Upload file
+				const result = await uploadBytes(fileRef, file, { customMetadata });
+				const size = result.metadata.size;
+
+				if (size) self.postMessage({ result: size, type: "result" });
+				else self.postMessage({ error: result, type: "error" });
+			} catch (error) {
+				// Upload error
+				self.postMessage({ error, type: "error" });
+			}
+
+			unsub();
+		});
+	} catch (error) {
+		// Initialization error
+		self.postMessage({ error, type: "error" });
+	}
+};

package/dist/runtime/server/api/all-collection-document.get.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get a document from a given collection
+ *
+ * @auth guest
+ */
+declare const _default: import("../types/index.js").CachedEventHandler<import("h3").EventHandlerRequest, Promise<void | import("../../client/types/index.js").FirebaseDocument>>;
+export default _default;