eny-ai 1.0.0 → 2.0.0

package/dist/firebase.cjs

@@ -0,0 +1,296 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/firebase/index.ts
+var firebase_exports = {};
+__export(firebase_exports, {
+  ENYFirebase: () => ENYFirebase,
+  firebase: () => firebase,
+  useAuth: () => useAuth,
+  useFirebase: () => useFirebase,
+  useRealtimeData: () => useRealtimeData
+});
+module.exports = __toCommonJS(firebase_exports);
+var import_app = require("firebase/app");
+var import_auth = require("firebase/auth");
+var import_database = require("firebase/database");
+var import_react = __toESM(require("react"), 1);
+var ENYFirebase = class {
+  constructor() {
+    this.app = null;
+    this.auth = null;
+    this.db = null;
+  }
+  /**
+   * ⚙️ - Inicializar Firebase
+   */
+  initialize(config) {
+    this.app = (0, import_app.initializeApp)(config);
+    this.auth = (0, import_auth.getAuth)(this.app);
+    this.db = (0, import_database.getDatabase)(this.app);
+    console.log("\u2705 Firebase inicializado");
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // MÉTODOS AUTENTICAÇÃO
+  // ═════════════════════════════════════════════════════════════════════════════
+  /**
+   * signin - Login com email/senha
+   * signin(email, password)
+   * Alias: 🔑(email, password)
+   */
+  async signin(email, password) {
+    if (!this.auth) throw new Error("Firebase not initialized");
+    try {
+      const credential = await (0, import_auth.signInWithEmailAndPassword)(this.auth, email, password);
+      console.log("\u2705 Login bem-sucedido:", email);
+      return {
+        user: credential.user,
+        success: true
+      };
+    } catch (error) {
+      console.error("\u274C Erro login:", error);
+      throw error;
+    }
+  }
+  /**
+   * signup - Criar conta
+   * signup(email, password)
+   * Alias: 📝(email, password)
+   */
+  async signup(email, password) {
+    if (!this.auth) throw new Error("Firebase not initialized");
+    try {
+      const credential = await (0, import_auth.createUserWithEmailAndPassword)(this.auth, email, password);
+      console.log("\u2705 Conta criada:", email);
+      return {
+        user: credential.user,
+        success: true
+      };
+    } catch (error) {
+      console.error("\u274C Erro criar conta:", error);
+      throw error;
+    }
+  }
+  /**
+   * signout - Logout
+   * signout()
+   * Alias: 🚪()
+   */
+  async signout() {
+    if (!this.auth) throw new Error("Firebase not initialized");
+    try {
+      await (0, import_auth.signOut)(this.auth);
+      console.log("\u{1F44B} Desconectado");
+      return { success: true };
+    } catch (error) {
+      console.error("\u274C Erro logout:", error);
+      throw error;
+    }
+  }
+  /**
+   * currentUser - Obter usuário atual
+   * Alias: 👤
+   */
+  get currentUser() {
+    return this.auth?.currentUser || null;
+  }
+  /**
+   * onAuthStateChange - Observar estado autenticação
+   * onAuthStateChange((user) => {...})
+   * Alias: 👁((user) => {...})
+   */
+  onAuthStateChange(callback) {
+    if (!this.auth) throw new Error("Firebase not initialized");
+    return (0, import_auth.onAuthStateChanged)(this.auth, callback);
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // MÉTODOS DATABASE
+  // ═════════════════════════════════════════════════════════════════════════════
+  /**
+   * write - Escrever dados
+   * write('users/123', { name: 'João' })
+   * Alias: 📊(path, data)
+   */
+  async write(path, data) {
+    if (!this.db) throw new Error("Firebase not initialized");
+    try {
+      const dbRef = (0, import_database.ref)(this.db, path);
+      await (0, import_database.set)(dbRef, data);
+      console.log("\u2705 Dados salvos:", path);
+      return { success: true };
+    } catch (error) {
+      console.error("\u274C Erro salvar:", error);
+      throw error;
+    }
+  }
+  /**
+   * read - Ler dados (uma vez)
+   * read('users/123')
+   * Alias: 🔍('users/123')
+   */
+  async read(path) {
+    if (!this.db) throw new Error("Firebase not initialized");
+    try {
+      const dbRef = (0, import_database.ref)(this.db, path);
+      const snapshot = await (0, import_database.get)(dbRef);
+      console.log("\u2705 Dados lidos:", path);
+      return snapshot.val();
+    } catch (error) {
+      console.error("\u274C Erro ler:", error);
+      throw error;
+    }
+  }
+  /**
+   * watch - Observar dados em tempo real
+   * watch('users/123', (data) => {...})
+   * Alias: 📡('users/123', (data) => {...})
+   */
+  watch(path, callback) {
+    if (!this.db) throw new Error("Firebase not initialized");
+    const dbRef = (0, import_database.ref)(this.db, path);
+    return (0, import_database.onValue)(dbRef, (snapshot) => {
+      callback(snapshot.val());
+    });
+  }
+  /**
+   * update - Atualizar dados específicos
+   * update('users/123', { name: 'João Silva' })
+   * Alias: ✏️('users/123', { name: 'João Silva' })
+   */
+  async updateData(path, data) {
+    if (!this.db) throw new Error("Firebase not initialized");
+    try {
+      const dbRef = (0, import_database.ref)(this.db, path);
+      await (0, import_database.update)(dbRef, data);
+      console.log("\u2705 Dados atualizados:", path);
+      return { success: true };
+    } catch (error) {
+      console.error("\u274C Erro atualizar:", error);
+      throw error;
+    }
+  }
+  /**
+   * delete - Deletar dados
+   * delete('users/123')
+   * Alias: 🗑️('users/123')
+   */
+  async delete(path) {
+    if (!this.db) throw new Error("Firebase not initialized");
+    try {
+      const dbRef = (0, import_database.ref)(this.db, path);
+      await (0, import_database.remove)(dbRef);
+      console.log("\u2705 Dados deletados:", path);
+      return { success: true };
+    } catch (error) {
+      console.error("\u274C Erro deletar:", error);
+      throw error;
+    }
+  }
+  /**
+   * query - Query com ordem/limite
+   * query('users', 'age', 10)
+   * Alias: 🔗('users', 'age', 10)
+   */
+  async queryData(path, orderBy = "", limit = 0) {
+    if (!this.db) throw new Error("Firebase not initialized");
+    try {
+      const dbRef = (0, import_database.ref)(this.db, path);
+      let q = dbRef;
+      if (orderBy) {
+        q = (0, import_database.query)(dbRef, (0, import_database.orderByChild)(orderBy));
+      }
+      if (limit) {
+        q = (0, import_database.query)(dbRef, (0, import_database.limitToFirst)(limit));
+      }
+      const snapshot = await (0, import_database.get)(q);
+      return snapshot.val();
+    } catch (error) {
+      console.error("\u274C Erro query:", error);
+      throw error;
+    }
+  }
+  // ═════════════════════════════════════════════════════════════════════════════
+  // HELPERS
+  // ═════════════════════════════════════════════════════════════════════════════
+  /**
+   * 🔐 - Contexto de autenticação
+   */
+  getAuth() {
+    return this.auth;
+  }
+  /**
+   * 📂 - Contexto de database
+   */
+  getDatabase() {
+    return this.db;
+  }
+  /**
+   * Verificar se está autenticado
+   */
+  isAuthenticated() {
+    return this.currentUser !== null;
+  }
+};
+var firebase = new ENYFirebase();
+function useFirebase() {
+  return firebase;
+}
+function useAuth(callback) {
+  const [user, setUser] = import_react.default.useState(null);
+  const [loading, setLoading] = import_react.default.useState(true);
+  import_react.default.useEffect(() => {
+    const unsubscribe = firebase.onAuthStateChange((u) => {
+      setUser(u);
+      setLoading(false);
+      callback?.(u);
+    });
+    return () => unsubscribe();
+  }, [callback]);
+  return { user, loading };
+}
+function useRealtimeData(path) {
+  const [data, setData] = import_react.default.useState(null);
+  const [loading, setLoading] = import_react.default.useState(true);
+  import_react.default.useEffect(() => {
+    const unsubscribe = firebase.watch(path, (d) => {
+      setData(d);
+      setLoading(false);
+    });
+    return () => unsubscribe();
+  }, [path]);
+  return { data, loading };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENYFirebase,
+  firebase,
+  useAuth,
+  useFirebase,
+  useRealtimeData
+});

package/dist/firebase.d.cts

@@ -0,0 +1,136 @@
+import { User } from 'firebase/auth';
+
+/**
+ * 🧠 ENY-AI FIREBASE - Auth e Database 90% Simbólicos
+ * Firebase is an optional peer dependency
+ */
+
+interface FirebaseConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId: string;
+}
+declare class ENYFirebase {
+    private app;
+    private auth;
+    private db;
+    /**
+     * ⚙️ - Inicializar Firebase
+     */
+    initialize(config: FirebaseConfig): void;
+    /**
+     * signin - Login com email/senha
+     * signin(email, password)
+     * Alias: 🔑(email, password)
+     */
+    signin(email: string, password: string): Promise<{
+        user: any;
+        success: boolean;
+    }>;
+    /**
+     * signup - Criar conta
+     * signup(email, password)
+     * Alias: 📝(email, password)
+     */
+    signup(email: string, password: string): Promise<{
+        user: any;
+        success: boolean;
+    }>;
+    /**
+     * signout - Logout
+     * signout()
+     * Alias: 🚪()
+     */
+    signout(): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * currentUser - Obter usuário atual
+     * Alias: 👤
+     */
+    get currentUser(): User | null;
+    /**
+     * onAuthStateChange - Observar estado autenticação
+     * onAuthStateChange((user) => {...})
+     * Alias: 👁((user) => {...})
+     */
+    onAuthStateChange(callback: (user: User | null) => void): any;
+    /**
+     * write - Escrever dados
+     * write('users/123', { name: 'João' })
+     * Alias: 📊(path, data)
+     */
+    write(path: string, data: any): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * read - Ler dados (uma vez)
+     * read('users/123')
+     * Alias: 🔍('users/123')
+     */
+    read(path: string): Promise<any>;
+    /**
+     * watch - Observar dados em tempo real
+     * watch('users/123', (data) => {...})
+     * Alias: 📡('users/123', (data) => {...})
+     */
+    watch(path: string, callback: (data: any) => void): any;
+    /**
+     * update - Atualizar dados específicos
+     * update('users/123', { name: 'João Silva' })
+     * Alias: ✏️('users/123', { name: 'João Silva' })
+     */
+    updateData(path: string, data: any): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * delete - Deletar dados
+     * delete('users/123')
+     * Alias: 🗑️('users/123')
+     */
+    delete(path: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * query - Query com ordem/limite
+     * query('users', 'age', 10)
+     * Alias: 🔗('users', 'age', 10)
+     */
+    queryData(path: string, orderBy?: string, limit?: number): Promise<any>;
+    /**
+     * 🔐 - Contexto de autenticação
+     */
+    getAuth(): any;
+    /**
+     * 📂 - Contexto de database
+     */
+    getDatabase(): any;
+    /**
+     * Verificar se está autenticado
+     */
+    isAuthenticated(): boolean;
+}
+declare const firebase: ENYFirebase;
+/**
+ * Hook React para Firebase
+ */
+declare function useFirebase(): ENYFirebase;
+/**
+ * Hook para observar autenticação
+ */
+declare function useAuth(callback?: (user: User | null) => void): {
+    user: any;
+    loading: boolean;
+};
+/**
+ * Hook para dados em tempo real
+ */
+declare function useRealtimeData(path: string): {
+    data: null;
+    loading: boolean;
+};
+
+export { ENYFirebase, firebase, useAuth, useFirebase, useRealtimeData };

package/dist/firebase.d.ts

@@ -0,0 +1,136 @@
+import { User } from 'firebase/auth';
+
+/**
+ * 🧠 ENY-AI FIREBASE - Auth e Database 90% Simbólicos
+ * Firebase is an optional peer dependency
+ */
+
+interface FirebaseConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId: string;
+}
+declare class ENYFirebase {
+    private app;
+    private auth;
+    private db;
+    /**
+     * ⚙️ - Inicializar Firebase
+     */
+    initialize(config: FirebaseConfig): void;
+    /**
+     * signin - Login com email/senha
+     * signin(email, password)
+     * Alias: 🔑(email, password)
+     */
+    signin(email: string, password: string): Promise<{
+        user: any;
+        success: boolean;
+    }>;
+    /**
+     * signup - Criar conta
+     * signup(email, password)
+     * Alias: 📝(email, password)
+     */
+    signup(email: string, password: string): Promise<{
+        user: any;
+        success: boolean;
+    }>;
+    /**
+     * signout - Logout
+     * signout()
+     * Alias: 🚪()
+     */
+    signout(): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * currentUser - Obter usuário atual
+     * Alias: 👤
+     */
+    get currentUser(): User | null;
+    /**
+     * onAuthStateChange - Observar estado autenticação
+     * onAuthStateChange((user) => {...})
+     * Alias: 👁((user) => {...})
+     */
+    onAuthStateChange(callback: (user: User | null) => void): any;
+    /**
+     * write - Escrever dados
+     * write('users/123', { name: 'João' })
+     * Alias: 📊(path, data)
+     */
+    write(path: string, data: any): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * read - Ler dados (uma vez)
+     * read('users/123')
+     * Alias: 🔍('users/123')
+     */
+    read(path: string): Promise<any>;
+    /**
+     * watch - Observar dados em tempo real
+     * watch('users/123', (data) => {...})
+     * Alias: 📡('users/123', (data) => {...})
+     */
+    watch(path: string, callback: (data: any) => void): any;
+    /**
+     * update - Atualizar dados específicos
+     * update('users/123', { name: 'João Silva' })
+     * Alias: ✏️('users/123', { name: 'João Silva' })
+     */
+    updateData(path: string, data: any): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * delete - Deletar dados
+     * delete('users/123')
+     * Alias: 🗑️('users/123')
+     */
+    delete(path: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * query - Query com ordem/limite
+     * query('users', 'age', 10)
+     * Alias: 🔗('users', 'age', 10)
+     */
+    queryData(path: string, orderBy?: string, limit?: number): Promise<any>;
+    /**
+     * 🔐 - Contexto de autenticação
+     */
+    getAuth(): any;
+    /**
+     * 📂 - Contexto de database
+     */
+    getDatabase(): any;
+    /**
+     * Verificar se está autenticado
+     */
+    isAuthenticated(): boolean;
+}
+declare const firebase: ENYFirebase;
+/**
+ * Hook React para Firebase
+ */
+declare function useFirebase(): ENYFirebase;
+/**
+ * Hook para observar autenticação
+ */
+declare function useAuth(callback?: (user: User | null) => void): {
+    user: any;
+    loading: boolean;
+};
+/**
+ * Hook para dados em tempo real
+ */
+declare function useRealtimeData(path: string): {
+    data: null;
+    loading: boolean;
+};
+
+export { ENYFirebase, firebase, useAuth, useFirebase, useRealtimeData };

package/dist/firebase.js

@@ -0,0 +1,17 @@
+import {
+  ENYFirebase,
+  firebase,
+  init_firebase,
+  useAuth,
+  useFirebase,
+  useRealtimeData
+} from "./chunk-5KPALVCK.js";
+import "./chunk-MXA7TAAG.js";
+init_firebase();
+export {
+  ENYFirebase,
+  firebase,
+  useAuth,
+  useFirebase,
+  useRealtimeData
+};