@open-xamu-co/firebase-nuxt 1.0.0-next.3 → 1.0.0-next.4

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 Firebase nuxt
 
+# [1.0.0-next.4](https://github.com/xamu-co/firebase-nuxt/compare/v1.0.0-next.3...v1.0.0-next.4) (2026-01-08)
+
+
+### Bug Fixes
+
+* include missing distributables ([a455111](https://github.com/xamu-co/firebase-nuxt/commit/a455111cb9500bc5755590cdd45da4b6e46f8ee3))
+
 # [1.0.0-next.3](https://github.com/xamu-co/firebase-nuxt/compare/v1.0.0-next.2...v1.0.0-next.3) (2026-01-08)
 
 

package/dist/module.d.mts

@@ -0,0 +1,54 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { ClientProvide } from '../dist/runtime/plugins/firebase-setup.js';
+import { H3Context } from '../dist/runtime/server/types/index.js';
+import { FirebaseNuxtPublicRuntimeConfig } from '../dist/runtime/server/utils/environment.js';
+
+/**
+ * Nuxt specific configuration
+ */
+interface FirebaseNuxtModuleOptions {
+    /** Enable tenants */
+    tenants: boolean;
+    /** Enable media */
+    media: boolean;
+    /**
+     * Whether the current auth is authorized to read the given instance's collection
+     *
+     * @server Runs server side only
+     */
+    readInstanceCollection: (collection: string, context: H3Context) => boolean;
+    /**
+     * Whether the current auth is authorized to read the given collection
+     *
+     * @server Runs server side only
+     */
+    readCollection: (collection: string, context: H3Context) => boolean;
+    /**
+     * Whether the current auth is a super user
+     *
+     * @server Runs server side only
+     */
+    sudo: (context: H3Context) => boolean;
+}
+declare module "nuxt/schema" {
+    interface PublicRuntimeConfig extends FirebaseNuxtPublicRuntimeConfig {
+    }
+}
+declare module "@nuxt/schema" {
+    interface PublicRuntimeConfig extends FirebaseNuxtPublicRuntimeConfig {
+    }
+}
+type Decorate<T extends Record<string, any>> = {
+    [K in keyof T as K extends string ? `$${K}` : never]: T[K];
+};
+declare module "#app" {
+    interface NuxtApp extends Decorate<ClientProvide> {
+    }
+}
+
+/**
+ * Nuxt module for @open-xamu-co/firebase-nuxt
+ */
+declare const _default: _nuxt_schema.NuxtModule<FirebaseNuxtModuleOptions, FirebaseNuxtModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@open-xamu-co/firebase-nuxt",
+  "configKey": "firebaseNuxt",
+  "compatibility": {
+    "nuxt": "^3.0.0"
+  },
+  "version": "1.0.0-next.3",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,137 @@
+import { defineNuxtModule, createResolver, addPlugin, addImportsDir, addComponentsDir, addServerTemplate, addServerHandler } from '@nuxt/kit';
+import { locale } from '../dist/runtime/client/utils/locale.js';
+import { debugNuxt, port, publicRuntimeConfig } from '../dist/runtime/server/utils/environment.js';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@open-xamu-co/firebase-nuxt",
+    configKey: "firebaseNuxt",
+    compatibility: { nuxt: "^3.0.0" }
+  },
+  async setup(moduleOptions, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    const runtimePath = resolve("./runtime");
+    nuxt.options.devtools.enabled = debugNuxt;
+    nuxt.options.devtools.timeline = { enabled: debugNuxt };
+    nuxt.options.experimental.asyncContext = true;
+    nuxt.options.experimental.viewTransition = true;
+    nuxt.options.nitro.compressPublicAssets = true;
+    nuxt.options.vite.optimizeDeps = {
+      ...nuxt.options.vite.optimizeDeps,
+      exclude: [
+        ...nuxt.options.vite.optimizeDeps?.exclude || [],
+        // Server imports
+        "nitropack/runtime"
+      ]
+    };
+    nuxt.options.vite.resolve = {
+      ...nuxt.options.vite.resolve,
+      dedupe: [
+        ...nuxt.options.vite.resolve?.dedupe || [],
+        "firebase",
+        "firebase/app",
+        "firebase/auth",
+        "firebase/app-check",
+        "firebase/firestore",
+        "firebase/analytics",
+        "pinia"
+      ]
+    };
+    if (debugNuxt) {
+      nuxt.options.devServer = { ...nuxt.options.devServer, host: "0.0.0.0", port };
+    }
+    nuxt.options.runtimeConfig.public = {
+      ...nuxt.options.runtimeConfig.public,
+      ...publicRuntimeConfig,
+      tenants: moduleOptions.tenants
+      // Globally available
+    };
+    addPlugin(resolve(runtimePath, "plugins/scrollBehavior.client"));
+    addPlugin(resolve(runtimePath, "plugins/firebase-setup"));
+    addPlugin(resolve(runtimePath, "plugins/loaded.client"));
+    addImportsDir(resolve(runtimePath, "composables"));
+    addComponentsDir({ path: resolve(runtimePath, "components") });
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.publicAssets ||= [];
+      nitroConfig.publicAssets.push({
+        dir: resolve(runtimePath, "public"),
+        maxAge: 60 * 60 * 24 * 365
+        // 1 year
+      });
+    });
+    addServerTemplate({
+      filename: "#internal/firebase-nuxt",
+      getContents: () => `
+				export const readInstanceCollection = ${moduleOptions.readInstanceCollection?.toString() || "() => false"};
+				export const readCollection = ${moduleOptions.readCollection?.toString() || "() => false"};
+				export const sudo = ${moduleOptions.sudo?.toString() || "() => false"};
+			`
+    });
+    addServerHandler({
+      middleware: true,
+      handler: resolve(runtimePath, "server/middleware/0.hotlinking")
+    });
+    addServerHandler({
+      middleware: true,
+      handler: resolve(runtimePath, "server/middleware/1.context")
+    });
+    if (moduleOptions.media) {
+      addServerHandler({
+        method: "get",
+        route: "/api/media/[...path]",
+        handler: resolve(runtimePath, "server/api/media.get")
+      });
+    }
+    addServerHandler({
+      method: "get",
+      route: "/api/all/:collectionId",
+      handler: resolve(runtimePath, "server/api/all-collection.get")
+    });
+    addServerHandler({
+      method: "get",
+      route: "/api/all/:collectionId/:documentId",
+      handler: resolve(runtimePath, "server/api/all-collection-document.get")
+    });
+    addServerHandler({
+      method: "get",
+      route: "/api/instance/all/:collectionId",
+      handler: resolve(runtimePath, "server/api/all-collection.get")
+    });
+    addServerHandler({
+      method: "get",
+      route: "/api/instance/all/:collectionId/:documentId",
+      handler: resolve(runtimePath, "server/api/all-collection-document.get")
+    });
+  },
+  moduleDependencies() {
+    const { resolve } = createResolver(import.meta.url);
+    const runtimePath = resolve("./runtime");
+    return {
+      "nuxt-csurf": {
+        version: ">=1.6.5"
+      },
+      "@open-xamu-co/ui-nuxt": {
+        version: ">=4.0.0-next.4",
+        defaults: {
+          locale,
+          lang: "es",
+          country: "CO",
+          image: {
+            provider: "firebase",
+            domains: ["firebasestorage.googleapis.com"],
+            providers: {
+              firebase: { provider: resolve(runtimePath, "providers/firebase") }
+            }
+          },
+          imageHosts: ["lh3.googleusercontent.com"],
+          imagePlaceholder: "/sample-missing.png"
+        }
+      },
+      "@pinia/nuxt": {
+        version: ">=0.11.0"
+      }
+    };
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/client/types/entities/base.d.ts

@@ -0,0 +1,29 @@
+import type { DocumentReference, Timestamp } from "firebase/firestore";
+import type { GetSharedRef } from "./user.js";
+import type { SharedDocument } from "./instance.js";
+export interface FirebaseDocument {
+    /** @automated Document path */
+    id?: string;
+    /** @automated Creation date */
+    createdAt?: string | Date;
+    /** @automated Last update date */
+    updatedAt?: string | Date;
+    /**
+     * Lock document & prevent deletion
+     * A boolean or an array of reference paths locking the document
+     *
+     * @automated
+     */
+    lock?: boolean | string[];
+}
+export type FromData<Data extends Record<string, any>> = {
+    [K in keyof Data as K extends `${string}Ref` | `${string}Refs` ? never : K]: K extends `${string}At` ? string | Date | undefined : Data[K];
+} & {
+    id?: string;
+    lock?: boolean | string[];
+};
+export type GetRef<T extends SharedDocument, O extends keyof T = never> = GetSharedRef<T, O> & {
+    createdAt?: Timestamp;
+    updatedAt?: Timestamp;
+    instanceRef?: DocumentReference;
+};

package/dist/runtime/client/types/entities/instance.d.ts

@@ -0,0 +1,42 @@
+import type { DocumentReference, FieldValue } from "firebase/firestore";
+import type { InstanceMemberData, InstanceLogData, InstanceData, RootData } from "../../../functions/types/index.js";
+import type { FirebaseDocument, FromData, GetRef } from "./base.js";
+import type { GetSharedRef, User, UserRef } from "./user.js";
+/**
+ * Document can be modified by any user
+ *
+ * This data is used to keep track of the changes
+ */
+export interface SharedDocument extends FirebaseDocument {
+    createdBy?: FirebaseDocument;
+    updatedBy?: FirebaseDocument;
+    deletedBy?: FirebaseDocument;
+}
+/** @output Root instance*/
+export interface Root extends SharedDocument, FromData<RootData> {
+}
+/** @input Omit automation */
+export interface RootRef extends GetSharedRef<Root> {
+}
+/** @output App instance */
+export interface Instance extends SharedDocument, FromData<InstanceData> {
+}
+/** @input Omit automation */
+export interface InstanceRef extends GetSharedRef<Instance> {
+}
+/** @output Firebase log */
+export interface InstanceLog extends SharedDocument, FromData<InstanceLogData> {
+}
+/** @input Omit automation */
+export interface InstanceLogRef extends GetSharedRef<InstanceLog> {
+}
+/** @output Instance member */
+export interface InstanceMember extends SharedDocument, FromData<InstanceMemberData> {
+    user?: User;
+    rootMember?: InstanceMember;
+}
+/** @input Omit automation */
+export interface InstanceMemberRef extends GetRef<InstanceMember> {
+    userRef?: DocumentReference<User, UserRef> | FieldValue;
+    rootMemberRef?: DocumentReference<InstanceMember, InstanceMemberRef> | FieldValue;
+}

package/dist/runtime/client/types/entities/logs.d.ts

@@ -0,0 +1,9 @@
+import type { LogData } from "../../../functions/types/index.js";
+import type { FromData } from "./base.js";
+import type { GetSharedRef } from "./user.js";
+/** @output Log */
+export interface Log extends FromData<LogData> {
+}
+/** @input Omit automation */
+export interface LogRef extends GetSharedRef<Log> {
+}

package/dist/runtime/client/types/entities/user.d.ts

@@ -0,0 +1,27 @@
+import type { DocumentReference, FieldValue } from "firebase/firestore";
+import type { UserData } from "../../../functions/types/index.js";
+import type { FromData } from "./base.js";
+import type { Instance, SharedDocument } from "./instance.js";
+/**
+ * Remove FirebaseDocument properties to make valid Ref
+ *
+ * Ref are used to create and modify firebase document
+ * Removed properties are not required or are part of automation
+ */
+export type GetSharedRef<T extends SharedDocument, O extends keyof T = never> = {
+    [K in keyof FromData<Omit<T, "id" | O>> as K extends `${string}At` ? never : K]: FromData<Omit<T, "id" | O>>[K];
+} & {
+    createdByRef?: DocumentReference | FieldValue;
+    updatedByRef?: DocumentReference | FieldValue;
+    deletedByRef?: DocumentReference | FieldValue;
+};
+/**
+ * Firebase user
+ */
+export interface User extends SharedDocument, FromData<UserData> {
+    instances?: Instance[];
+}
+/** This one goes to the database */
+export interface UserRef extends GetSharedRef<User, "instances"> {
+    instancesRefs?: DocumentReference[] | FieldValue;
+}

package/dist/runtime/client/types/firestore.d.ts

@@ -0,0 +1,55 @@
+import type { iPagination, tLogger } from "@open-xamu-co/ui-common-types";
+import type { FirebaseDocument, FromData } from "./entities/base.js";
+export interface PseudoNode extends Record<string, any> {
+    [key: `${string}Ref`]: Record<string, any>;
+    [key: `${string}Refs`]: Record<string, any>[];
+}
+export interface PseudoDocumentSnapshot<T extends PseudoNode, R extends FirebaseDocument = FromData<T>> extends Record<string, any> {
+    data(): T | undefined;
+    exists: boolean | (() => this is PseudoDocumentSnapshot<T, R>);
+}
+export interface PseudoDocumentReference<T extends PseudoNode, R extends FirebaseDocument = FromData<T>> extends Record<string, any> {
+    get: () => Promise<PseudoDocumentSnapshot<T, R>>;
+    converter: any;
+    type: any;
+    firestore: any;
+    id: any;
+    parent: any;
+    path: any;
+    withConverter: any;
+    toJSON: any;
+}
+export interface iSnapshotConfig {
+    /**
+     * Refs level
+     *
+     * @default 0 - All refs will be omited
+     */
+    level?: number;
+    /**
+     * Omit these properties
+     *
+     * to omit "productRef"
+     * @example { omit: [ "product"]}
+     */
+    omit?: string[];
+    logger?: tLogger;
+}
+export interface iUseEdges extends iPagination, iSnapshotConfig {
+    /**
+     * Get these specific documents from collection.
+     *
+     * @example "nodeUid" and "collectionId/nodeUid" are valid id structures
+     *
+     * According to firebase docs, queries are limited to 30 disjuntion operations
+     * @see https://firebase.google.com/docs/firestore/query-data/queries#limits_on_or_queries
+     */
+    include?: boolean | string[];
+}
+export interface iUsePage extends iUseEdges {
+    /**
+     * Bypass limitations
+     */
+    visible?: boolean;
+    page?: boolean;
+}

package/dist/runtime/client/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./entities/base.js";
+export * from "./entities/user.js";
+export * from "./entities/instance.js";
+export * from "./entities/logs.js";
+export * from "./firestore.js";

package/dist/runtime/client/types/index.js

@@ -0,0 +1,5 @@
+export * from "./entities/base.js";
+export * from "./entities/user.js";
+export * from "./entities/instance.js";
+export * from "./entities/logs.js";
+export * from "./firestore.js";

package/dist/runtime/client/utils/locale.d.ts

@@ -0,0 +1,185 @@
+export declare const locale: {
+    refresh: string;
+    table_update: string;
+    yes: string;
+    no: string;
+    increase: string;
+    decrease: string;
+    could_not_get_data: string;
+    nothing_to_show: string;
+    loading: string;
+    close: string;
+    ok: string;
+    see_value: string;
+    see_name: string;
+    add: string;
+    clear: string;
+    required_verification: string;
+    previous: string;
+    next: string;
+    send: string;
+    delete: string;
+    delete_all: string;
+    pick: string;
+    render_error: string;
+    swal: {
+        cancel: string;
+        continue: string;
+        error: string;
+        error_message: string;
+        connection_error: string;
+        connection_error_message: string;
+        connection_error_confirm: string;
+        incomplete_data: string;
+        incomplete_data_message: string;
+        dont_close_window: string;
+    } & {
+        file_limit: string;
+        file_limit_text: string;
+        file_unsupported_format: string;
+        file_unsupported_format_text: string;
+        file_wrong_format: string;
+        file_wrong_format_text: string;
+        file_too_big: string;
+        file_too_big_text: string;
+        file_unknown_error: string;
+        file_unknown_error_text: string;
+    } & {
+        modal_unauthorized: string;
+        modal_unauthorized_text: string;
+    } & {
+        table_delete_node_title: string;
+        table_delete_node_disclaimer: string;
+        table_deleted: string;
+        table_deleted_text: string;
+        table_delete_nodes_title: string;
+        table_delete_nodes_disclaimer: string;
+        table_possibly_not_deleted: string;
+        table_possibly_not_deleted_text: string;
+        table_updated: string;
+        table_updated_text: string;
+        table_possibly_not_updated: string;
+        table_possibly_not_updated_text: string;
+        table_created: string;
+        table_created_text: string;
+        table_possibly_not_created: string;
+        table_possibly_not_created_text: string;
+        table_cloned: string;
+        table_cloned_text: string;
+        table_possibly_not_cloned: string;
+        table_possibly_not_cloned_text: string;
+    };
+    select_selected: string;
+    select_placeholder: string;
+    select_restablish_field: string;
+    select_filter_options: string;
+    file_one_of_amount: string;
+    file_delete_files: string;
+    file_thumb: string;
+    file_choose_file: string;
+    file_or_drop_files_here: string;
+    file_max_file_size_mb: string;
+    file_drop_files_here: string;
+    file_completed: string;
+    file_loading_files: string;
+    modal_taking_too_long: string;
+    form_required_options: string;
+    form_requires_n_values: string;
+    form_loading_countries: string;
+    form_awaiting_countries: string;
+    form_country: string;
+    form_state: string;
+    form_city: string;
+    form_desired_password: string;
+    form_confirm_password: string;
+    form_check_password: string;
+    form_password: string;
+    form_email: string;
+    form_phone_line: string;
+    form_cellphone: string;
+    form_id_number: string;
+    form_complete_the_field: string;
+    form_location: string;
+    form_invalid_field: string;
+    form_required_field: string;
+    form_use_valid_email: string;
+    form_use_valid_phone: string;
+    form_use_valid_cellphone: string;
+    form_unmatching_passwords: string;
+    form_invalid_data: string;
+    form_no_values: string;
+    form_new_value: string;
+    table_see_values: string;
+    table_see_name: string;
+    table_hide_name: string;
+    table_create_new: string;
+    table_create_new_name: string;
+    table_quantity: string;
+    table_modify: string;
+    table_select: string;
+    table_select_all: string;
+    table_update_name: string;
+    table_delete: string;
+    table_delete_name: string;
+    table_showing_name: string;
+    table_sort_by_name: string;
+    table_duplicate: string;
+    table_options: string;
+    table_open_url: string;
+    table_hide_all: string;
+    table_show_all: string;
+    pagination_items: string;
+    pagination_pages: string;
+    pagination_page: string;
+    address: string;
+    at: string;
+    body: string;
+    categories: string;
+    category: string;
+    cellphone: string;
+    description: string;
+    document: string;
+    due_at: string;
+    highlight: string;
+    image: string;
+    images: string;
+    is_anonymous: string;
+    keywords: string;
+    location_city: string;
+    location_country: string;
+    location_state: string;
+    location: string;
+    lock: string;
+    main_variant: string;
+    main: string;
+    message: string;
+    metadata: string;
+    month: string;
+    name: string;
+    observations: string;
+    old_observations: string;
+    paid_at: string;
+    pending_quantity: string;
+    photo_url: string;
+    possible_variants: string;
+    price: string;
+    product: string;
+    quantity: string;
+    reference: string;
+    role: string;
+    sales: string;
+    slug: string;
+    sold_quantity: string;
+    tracking_code: string;
+    type: string;
+    uid: string;
+    value: string;
+    values: string;
+    variants: string;
+    visible_products: string;
+    with_debug_key: string;
+    created_at: string;
+    created_by: string;
+    updated_at: string;
+    updated_by: string;
+};

package/dist/runtime/client/utils/locale.js

@@ -0,0 +1,63 @@
+import es from "@open-xamu-co/ui-common-helpers/es";
+export const locale = {
+  // values
+  address: "Direcci\xF3n",
+  at: "Lugar",
+  body: "Cuerpo",
+  categories: "Categor\xEDas",
+  category: "Categor\xEDa",
+  cellphone: "Celular",
+  description: "Descripci\xF3n",
+  document: "Documento",
+  due_at: "Vencimiento",
+  highlight: "Principal",
+  image: "Imagen",
+  images: "Im\xE1genes",
+  is_anonymous: "An\xF3nimo",
+  keywords: "Palabras clave",
+  location_city: "Ciudad",
+  location_country: "Pa\xEDs",
+  location_state: "Departamento",
+  location: "Ubicaci\xF3n",
+  lock: "Bloqueado",
+  main_variant: "Variante principal",
+  main: "Principal",
+  message: "Mensaje",
+  metadata: "Metadatos",
+  month: "Mes",
+  name: "Nombre",
+  observations: "Observaciones",
+  old_observations: "Historial",
+  paid_at: "Pagado",
+  pending_quantity: "Pendiente",
+  // Cantidad pendiente
+  photo_url: "Foto",
+  possible_variants: "Variantes posibles",
+  price: "Precio",
+  product: "Producto",
+  quantity: "Cantidad",
+  reference: "Referencia",
+  role: "rol",
+  sales: "Ventas",
+  slug: "Etiqueta",
+  sold_quantity: "Vendido",
+  // Cantidad vendida
+  tracking_code: "C\xF3digo de rastreo",
+  type: "Tipo",
+  uid: "Referencia",
+  value: "Valor",
+  values: "Valores",
+  variants: "Variantes",
+  visible_products: "Productos visibles",
+  with_debug_key: "Modo de pruebas",
+  // Across all tables
+  created_at: "Creado",
+  created_by: "Creado por",
+  updated_at: "Actualizado",
+  updated_by: "Actualizado por",
+  // Prefer locale definitions
+  ...es,
+  // Explicit override
+  refresh: "Actualizar",
+  table_update: "Editar"
+};

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

@@ -0,0 +1,14 @@
+import { Firestore } from "firebase/firestore";
+import type { tLogger } from "@open-xamu-co/ui-common-types";
+interface iMakeLogger {
+    instanceId?: string;
+    authId?: string;
+    loggerFirestore?: Firestore;
+}
+/**
+ * Logger
+ * No circular dependencies or nuxt context
+ * Conditionally log user data
+ */
+export declare function makeLogger({ instanceId, authId, loggerFirestore }?: iMakeLogger): tLogger;
+export {};