@digitalaidseattle/firebase 1.0.9 → 1.0.12

package/dist/digitalaidseattle-firebase.esm.js

@@ -3,36 +3,36 @@ import _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';
 import _createClass from '@babel/runtime/helpers/esm/createClass';
 import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
-import { getAuth, GoogleAuthProvider, signInWithPopup } from 'firebase/auth';
+import { onAuthStateChanged, GoogleAuthProvider, signInWithPopup, getAuth } from 'firebase/auth';
 import { initializeApp } from 'firebase/app';
-import { ref, getDownloadURL, getStorage, getBytes } from 'firebase/storage';
+import { ref, getDownloadURL, getBytes, deleteObject, getMetadata, listAll, uploadBytes, getStorage } from 'firebase/storage';
 import _objectSpread from '@babel/runtime/helpers/esm/objectSpread2';
-import { getDocs, collection, getDoc, doc, addDoc, updateDoc, deleteDoc, getFirestore } from 'firebase/firestore';
-
-var firebaseConfig = {
-  apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
-  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
-  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
-  storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
-  messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
-  appId: import.meta.env.VITE_FIREBASE_APP_ID,
-  measurementId: import.meta.env.VITE_FIREBASE_MEASUREMENT_ID
-};
-
-// Initialize Firebase
-var firebaseClient = initializeApp(firebaseConfig);
+import { getDocs, collection, getDoc, doc, addDoc, updateDoc, deleteDoc, setDoc, getFirestore } from 'firebase/firestore';
+import { firebaseClient as firebaseClient$1 } from '@digitalaidseattle/firebase';
+import { getGenerativeModel, Schema, getAI, GoogleAIBackend } from 'firebase/ai';
 
 var FirebaseAuthService = /*#__PURE__*/function () {
-  function FirebaseAuthService() {
+  function FirebaseAuthService(firebaseClient) {
     var _this = this;
     _classCallCheck(this, FirebaseAuthService);
-    _defineProperty(this, "currentUser", undefined);
-    _defineProperty(this, "auth", getAuth(firebaseClient));
     _defineProperty(this, "getUser", /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
       return _regeneratorRuntime.wrap(function (_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            return _context.abrupt("return", _this.currentUser);
+            return _context.abrupt("return", new Promise(function (resolve) {
+              var unsubscribe = onAuthStateChanged(_this.auth, function (gUser) {
+                unsubscribe(); // stop listening after first call
+                var user = gUser ? {
+                  email: gUser.email,
+                  user_metadata: {
+                    name: gUser.displayName,
+                    avatar_url: gUser.photoURL,
+                    email: gUser.email
+                  }
+                } : null;
+                resolve(user);
+              });
+            }));
           case 1:
           case "end":
             return _context.stop();
@@ -43,19 +43,20 @@ var FirebaseAuthService = /*#__PURE__*/function () {
       return _regeneratorRuntime.wrap(function (_context2) {
         while (1) switch (_context2.prev = _context2.next) {
           case 0:
-            _this.currentUser = undefined;
-            _this.auth.signOut();
+            _context2.next = 1;
+            return _this.auth.signOut();
+          case 1:
             return _context2.abrupt("return", {
               error: null
             });
-          case 1:
+          case 2:
           case "end":
             return _context2.stop();
         }
       }, _callee2);
     })));
     _defineProperty(this, "signInWithGoogle", /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
-      var provider, resp, _t;
+      var provider, _t;
       return _regeneratorRuntime.wrap(function (_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
@@ -64,15 +65,6 @@ var FirebaseAuthService = /*#__PURE__*/function () {
             _context3.next = 1;
             return signInWithPopup(_this.auth, provider);
           case 1:
-            resp = _context3.sent;
-            _this.currentUser = {
-              email: resp.user.email,
-              user_metadata: {
-                name: resp.user.displayName,
-                avatar_url: resp.user.photoURL,
-                email: resp.user.email
-              }
-            };
             return _context3.abrupt("return", {
               data: {
                 url: import.meta.env.VITE_AUTH_DOMAIN
@@ -81,25 +73,15 @@ var FirebaseAuthService = /*#__PURE__*/function () {
           case 2:
             _context3.prev = 2;
             _t = _context3["catch"](0);
-            console.error(_t);
+            console.error('signInWithGoogle', _t);
+            throw _t;
           case 3:
           case "end":
             return _context3.stop();
         }
       }, _callee3, null, [[0, 2]]);
     })));
-    this.auth.onAuthStateChanged(function (user) {
-      if (user) {
-        _this.currentUser = {
-          email: user.email,
-          user_metadata: {
-            name: user.displayName,
-            avatar_url: user.photoURL,
-            email: user.email
-          }
-        };
-      }
-    });
+    this.auth = getAuth(firebaseClient);
   }
   return _createClass(FirebaseAuthService, [{
     key: "getProviders",
@@ -119,17 +101,34 @@ var FirebaseAuthService = /*#__PURE__*/function () {
   }, {
     key: "hasUser",
     value: function hasUser() {
-      return Promise.resolve(this.currentUser !== null);
+      var _this2 = this;
+      return new Promise(function (resolve) {
+        var unsubscribe = onAuthStateChanged(_this2.auth, function (user) {
+          unsubscribe(); // stop listening after first call
+          resolve(user ? true : false);
+        });
+      });
     }
   }]);
 }();
 
+var firebaseConfig = {
+  apiKey: import.meta.env.VITE_FIREBASE_API_KEY,
+  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN,
+  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID,
+  storageBucket: import.meta.env.VITE_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: import.meta.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
+  appId: import.meta.env.VITE_FIREBASE_APP_ID,
+  measurementId: import.meta.env.VITE_FIREBASE_MEASUREMENT_ID
+};
+
+// Initialize Firebase
+var firebaseClient = initializeApp(firebaseConfig);
+
 var FirebaseStorageService = /*#__PURE__*/function () {
-  function FirebaseStorageService() {
+  function FirebaseStorageService(firebaseClient) {
     var _this = this;
     _classCallCheck(this, FirebaseStorageService);
-    _defineProperty(this, "storage", getStorage(firebaseClient));
-    _defineProperty(this, "decoder", new TextDecoder("utf-8"));
     _defineProperty(this, "downloadFile", /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(filepath) {
         var fileRef;
@@ -150,6 +149,8 @@ var FirebaseStorageService = /*#__PURE__*/function () {
         return _ref.apply(this, arguments);
       };
     }());
+    this.storage = getStorage(firebaseClient);
+    this.decoder = new TextDecoder("utf-8");
   }
   return _createClass(FirebaseStorageService, [{
     key: "getUrlAsync",
@@ -181,31 +182,128 @@ var FirebaseStorageService = /*#__PURE__*/function () {
       }
       return getUrlAsync;
     }()
-  }, {
-    key: "list",
-    value: function list(filepath) {
-      throw new Error("Method not implemented.");
-    }
   }, {
     key: "getUrl",
     value: function getUrl(filepath) {
       throw new Error("Method not supported.");
     }
-  }, {
-    key: "upload",
-    value: function upload(path, blob) {
-      throw new Error("Method not implemented.");
-    }
   }, {
     key: "downloadBlob",
     value: function downloadBlob(filepath) {
-      throw new Error("Method not implemented.");
+      var fileRef = ref(this.storage, filepath);
+      return getBytes(fileRef).then(function (bytes) {
+        return new Blob([bytes]);
+      });
     }
   }, {
     key: "removeFile",
-    value: function removeFile(fileName) {
-      throw new Error("Method not implemented.");
+    value: function removeFile(path) {
+      try {
+        var fileRef = ref(this.storage, path);
+        return deleteObject(fileRef);
+      } catch (error) {
+        if (error.code === "storage/object-not-found") {
+          console.warn("File does not exist");
+        } else if (error.code === "storage/unauthorized") {
+          console.error("User not authorized to delete file");
+        } else {
+          console.error("Delete failed:", error);
+        }
+        throw error;
+      }
     }
+  }, {
+    key: "list",
+    value: function () {
+      var _list = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(filepath) {
+        var folderRef, result, files;
+        return _regeneratorRuntime.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              if (filepath) {
+                _context4.next = 1;
+                break;
+              }
+              return _context4.abrupt("return", []);
+            case 1:
+              folderRef = ref(this.storage, filepath);
+              _context4.next = 2;
+              return listAll(folderRef);
+            case 2:
+              result = _context4.sent;
+              _context4.next = 3;
+              return Promise.all(result.items.map(/*#__PURE__*/function () {
+                var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(item) {
+                  var metadata;
+                  return _regeneratorRuntime.wrap(function (_context3) {
+                    while (1) switch (_context3.prev = _context3.next) {
+                      case 0:
+                        _context3.next = 1;
+                        return getMetadata(item);
+                      case 1:
+                        metadata = _context3.sent;
+                        return _context3.abrupt("return", {
+                          name: item.name,
+                          fullPath: item.fullPath,
+                          type: metadata.contentType,
+                          size: metadata.size,
+                          updated: metadata.updated
+                        });
+                      case 2:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }, _callee3);
+                }));
+                return function (_x4) {
+                  return _ref2.apply(this, arguments);
+                };
+              }()));
+            case 3:
+              files = _context4.sent;
+              return _context4.abrupt("return", files);
+            case 4:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function list(_x3) {
+        return _list.apply(this, arguments);
+      }
+      return list;
+    }()
+  }, {
+    key: "upload",
+    value: function () {
+      var _upload = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(path, file) {
+        var storageRef, snapshot, downloadUrl;
+        return _regeneratorRuntime.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              storageRef = ref(this.storage, path); // Upload file
+              _context5.next = 1;
+              return uploadBytes(storageRef, file, {
+                contentType: file === null || file === void 0 ? void 0 : file.type
+              });
+            case 1:
+              snapshot = _context5.sent;
+              _context5.next = 2;
+              return getDownloadURL(snapshot.ref);
+            case 2:
+              downloadUrl = _context5.sent;
+              return _context5.abrupt("return", downloadUrl);
+            case 3:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function upload(_x5, _x6) {
+        return _upload.apply(this, arguments);
+      }
+      return upload;
+    }()
   }]);
 }();
 
@@ -397,7 +495,108 @@ var FirestoreService = /*#__PURE__*/function () {
       }
       return _delete;
     }()
+  }, {
+    key: "upsert",
+    value: function () {
+      var _upsert = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7(entity) {
+        return _regeneratorRuntime.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.next = 1;
+              return setDoc(doc(this.db, this.collectionName, entity.id), entity);
+            case 1:
+              return _context7.abrupt("return", entity);
+            case 2:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function upsert(_x19) {
+        return _upsert.apply(this, arguments);
+      }
+      return upsert;
+    }()
+  }]);
+}();
+
+var GeminiService = /*#__PURE__*/function () {
+  function GeminiService(modelType) {
+    _classCallCheck(this, GeminiService);
+    this.ai = getAI(firebaseClient$1, {
+      backend: new GoogleAIBackend()
+    });
+  }
+  return _createClass(GeminiService, [{
+    key: "getModels",
+    value: function getModels() {
+      return ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.5-flash-lite"];
+    }
+  }, {
+    key: "calcTokenCount",
+    value: function calcTokenCount(model, prompt) {
+      return getGenerativeModel(this.ai, {
+        model: model
+      }).countTokens(prompt).then(function (response) {
+        return response.totalTokens;
+      });
+    }
+
+    // Wrap in an async function so you can use await
+  }, {
+    key: "generateContent",
+    value: function generateContent(model, prompt) {
+      // To generate text output, call generateContent with the text input
+      console.log('generateContent', model, prompt);
+      return getGenerativeModel(this.ai, {
+        model: model
+      }).generateContent(prompt).then(function (result) {
+        return result.response.text();
+      })["catch"](function (error) {
+        console.error("Error querying AI: ", error);
+        throw new Error("Failed to query AI: " + error.message);
+      });
+    }
+
+    // Wrap in an async function so you can use await
+  }, {
+    key: "generateParameterizedContent",
+    value: function generateParameterizedContent(model, prompt, schemaParams) {
+      // Provide a JSON schema object using a standard format.
+      // Later, pass this schema object into `responseSchema` in the generation config.
+      var schema = Schema.object({
+        properties: {
+          characters: Schema.array({
+            items: Schema.object({
+              properties: Object.fromEntries(schemaParams.map(function (field) {
+                return [field, Schema.string()];
+              }))
+            })
+          })
+        }
+      });
+
+      // Create a `GenerativeModel` instance with a model that supports your use case
+      var jModel = getGenerativeModel(this.ai, {
+        model: model,
+        // In the generation config, set the `responseMimeType` to `application/json`
+        // and pass the JSON schema object into `responseSchema`.
+        generationConfig: {
+          responseMimeType: "application/json",
+          responseSchema: schema
+        }
+      });
+
+      // To generate text output, call generateContent with the text input
+      return jModel.generateContent(prompt).then(function (result) {
+        var content = result.response.text();
+        return JSON.parse(content).characters[0];
+      })["catch"](function (error) {
+        console.error("Error querying AI: ", error);
+        throw new Error("Failed to query AI: " + error.message);
+      });
+    }
   }]);
 }();
 
-export { FirebaseAuthService, FirebaseStorageService, FirestoreService, firebaseClient };
+export { FirebaseAuthService, FirebaseStorageService, FirestoreService, GeminiService, firebaseClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitalaidseattle/firebase",
-  "version": "1.0.9",
+  "version": "1.0.12",
   "description": "Wrapper for firebase that works with DAS Component library",
   "repository": "null//github.com/null/github.com/tree/master/packages/firebase",
   "main": "dist/digitalaidseattle-firebase.cjs.js",
@@ -8,10 +8,10 @@
   "types": "dist/declarations/src/index.d.ts",
   "dependencies": {
     "@babel/runtime": "^7.25.0",
-    "@digitalaidseattle/core": "1.0.14",
+    "@digitalaidseattle/core": "1.0.17",
     "firebase": "^11.2.0",
     "react": "^18.3.1",
-    "uuid": "^11.0.5"
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "@testing-library/react": "^14.2.1",