@sneat/core 0.26.6 → 0.27.0

package/esm2022/lib/firebase.tokens.js

@@ -0,0 +1,54 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Angular DI tokens for the app's initialized firebase modular SDK instances.
+ *
+ * ## Why they live in `@sneat/core`
+ *
+ * The instances themselves are created by `provideSneatFirebase()` in
+ * `@sneat/app-auth`, which sits at the *top* of the dependency graph — it
+ * depends on `@sneat/auth-core`, `@sneat/logging` and `@sneat/api-*`. Those
+ * lower libs are the ones that need to *inject* Auth/App/Analytics
+ * (`SneatAuthStateService`, `FirebaseSneatApiAuthAdapter`, the analytics
+ * fan-out), so declaring the tokens in `@sneat/app-auth` would make every one
+ * of them import their own dependent — a cycle nx's
+ * `enforce-module-boundaries` rejects.
+ *
+ * `@sneat/core` is the one lib every consumer already depends on, and it
+ * already owns the matching `IFirebaseConfig`/`FirebaseConfigToken`
+ * declarations, so the tokens belong here. `@sneat/app-auth` re-exports all
+ * three, so `import { SNEAT_FIREBASE_AUTH } from '@sneat/app-auth'` — the
+ * import path documented when these tokens shipped — keeps working unchanged.
+ *
+ * ## Why the firebase imports are type-only
+ *
+ * `FirebaseApp`, `Auth` and `Analytics` are interfaces in the modular SDK, so
+ * `import type` erases completely at compile time. `@sneat/core` therefore
+ * gains **no** runtime dependency on `firebase` from this file — the peer is
+ * declared optional for exactly that reason.
+ */
+/**
+ * DI token for the app's initialized `firebase/app` `FirebaseApp` instance.
+ *
+ * `FirebaseApp` is a plain interface in the modular SDK (no runtime class),
+ * so — unlike `Firestore` — it cannot be used as an injection token by
+ * itself; inject this token instead, e.g. `inject(SNEAT_FIREBASE_APP)`.
+ */
+export const SNEAT_FIREBASE_APP = new InjectionToken('SNEAT_FIREBASE_APP');
+/**
+ * DI token for the app's initialized `firebase/auth` `Auth` instance.
+ * Same rationale as `SNEAT_FIREBASE_APP`: `Auth` is interface-only upstream.
+ */
+export const SNEAT_FIREBASE_AUTH = new InjectionToken('SNEAT_FIREBASE_AUTH');
+/**
+ * DI token for the app's `firebase/analytics` `Analytics` instance.
+ *
+ * Resolves to `null` — never throws — when analytics isn't configured (no
+ * real `measurementId`, using the fleet's `'G-PROVIDE_IF_NEEDED'` sentinel)
+ * or when `getAnalytics()` throws in an environment that doesn't support it
+ * (SSR, some webviews, privacy-hardened browsers). The factory only runs the
+ * first time something actually injects this token, so an app that never
+ * injects it never pays for Analytics initialization at all — consumers must
+ * treat the value as optional either way.
+ */
+export const SNEAT_FIREBASE_ANALYTICS = new InjectionToken('SNEAT_FIREBASE_ANALYTICS');
+//# sourceMappingURL=firebase.tokens.js.map

package/esm2022/lib/firebase.tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firebase.tokens.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/firebase.tokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAK/C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,cAAc,CAClD,oBAAoB,CACrB,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,cAAc,CACnD,qBAAqB,CACtB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,IAAI,cAAc,CACxD,0BAA0B,CAC3B,CAAC","sourcesContent":["import { InjectionToken } from '@angular/core';\nimport type { FirebaseApp } from 'firebase/app';\nimport type { Analytics } from 'firebase/analytics';\nimport type { Auth } from 'firebase/auth';\n\n/**\n * Angular DI tokens for the app's initialized firebase modular SDK instances.\n *\n * ## Why they live in `@sneat/core`\n *\n * The instances themselves are created by `provideSneatFirebase()` in\n * `@sneat/app-auth`, which sits at the *top* of the dependency graph — it\n * depends on `@sneat/auth-core`, `@sneat/logging` and `@sneat/api-*`. Those\n * lower libs are the ones that need to *inject* Auth/App/Analytics\n * (`SneatAuthStateService`, `FirebaseSneatApiAuthAdapter`, the analytics\n * fan-out), so declaring the tokens in `@sneat/app-auth` would make every one\n * of them import their own dependent — a cycle nx's\n * `enforce-module-boundaries` rejects.\n *\n * `@sneat/core` is the one lib every consumer already depends on, and it\n * already owns the matching `IFirebaseConfig`/`FirebaseConfigToken`\n * declarations, so the tokens belong here. `@sneat/app-auth` re-exports all\n * three, so `import { SNEAT_FIREBASE_AUTH } from '@sneat/app-auth'` — the\n * import path documented when these tokens shipped — keeps working unchanged.\n *\n * ## Why the firebase imports are type-only\n *\n * `FirebaseApp`, `Auth` and `Analytics` are interfaces in the modular SDK, so\n * `import type` erases completely at compile time. `@sneat/core` therefore\n * gains **no** runtime dependency on `firebase` from this file — the peer is\n * declared optional for exactly that reason.\n */\n\n/**\n * DI token for the app's initialized `firebase/app` `FirebaseApp` instance.\n *\n * `FirebaseApp` is a plain interface in the modular SDK (no runtime class),\n * so — unlike `Firestore` — it cannot be used as an injection token by\n * itself; inject this token instead, e.g. `inject(SNEAT_FIREBASE_APP)`.\n */\nexport const SNEAT_FIREBASE_APP = new InjectionToken<FirebaseApp>(\n  'SNEAT_FIREBASE_APP',\n);\n\n/**\n * DI token for the app's initialized `firebase/auth` `Auth` instance.\n * Same rationale as `SNEAT_FIREBASE_APP`: `Auth` is interface-only upstream.\n */\nexport const SNEAT_FIREBASE_AUTH = new InjectionToken<Auth>(\n  'SNEAT_FIREBASE_AUTH',\n);\n\n/**\n * DI token for the app's `firebase/analytics` `Analytics` instance.\n *\n * Resolves to `null` — never throws — when analytics isn't configured (no\n * real `measurementId`, using the fleet's `'G-PROVIDE_IF_NEEDED'` sentinel)\n * or when `getAnalytics()` throws in an environment that doesn't support it\n * (SSR, some webviews, privacy-hardened browsers). The factory only runs the\n * first time something actually injects this token, so an app that never\n * injects it never pays for Analytics initialization at all — consumers must\n * treat the value as optional either way.\n */\nexport const SNEAT_FIREBASE_ANALYTICS = new InjectionToken<Analytics | null>(\n  'SNEAT_FIREBASE_ANALYTICS',\n);\n"]}

package/esm2022/lib/index.js

@@ -21,4 +21,5 @@ export * from './directives';
 export * from './environment-config';
 export * from './logging/interfaces';
 export * from './analytics.interface';
+export * from './firebase.tokens';
 //# sourceMappingURL=index.js.map

package/esm2022/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,MAAM,CAAC;AACrB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC","sourcesContent":["export * from './animations';\nexport * from './app.service';\nexport * from './core-models';\nexport * from './nav';\nexport * from './store';\nexport * from './sneat-enum-keys';\nexport * from './services';\nexport * from './exclude-undefined';\nexport * from './logging';\nexport * from './utils';\nexport * from './eq';\nexport * from './types';\nexport * from './sneat-extensions';\nexport * from './form-field';\nexport * from './team-type';\nexport * from './location-href';\nexport * from './reserved-public-path';\nexport * from './interfaces';\nexport * from './current-space-storage';\nexport * from './directives';\nexport * from './environment-config';\nexport * from './logging/interfaces';\nexport * from './analytics.interface';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/core/src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,MAAM,CAAC;AACrB,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC","sourcesContent":["export * from './animations';\nexport * from './app.service';\nexport * from './core-models';\nexport * from './nav';\nexport * from './store';\nexport * from './sneat-enum-keys';\nexport * from './services';\nexport * from './exclude-undefined';\nexport * from './logging';\nexport * from './utils';\nexport * from './eq';\nexport * from './types';\nexport * from './sneat-extensions';\nexport * from './form-field';\nexport * from './team-type';\nexport * from './location-href';\nexport * from './reserved-public-path';\nexport * from './interfaces';\nexport * from './current-space-storage';\nexport * from './directives';\nexport * from './environment-config';\nexport * from './logging/interfaces';\nexport * from './analytics.interface';\nexport * from './firebase.tokens';\n"]}

package/lib/firebase.tokens.d.ts

@@ -0,0 +1,56 @@
+import { InjectionToken } from '@angular/core';
+import type { FirebaseApp } from 'firebase/app';
+import type { Analytics } from 'firebase/analytics';
+import type { Auth } from 'firebase/auth';
+/**
+ * Angular DI tokens for the app's initialized firebase modular SDK instances.
+ *
+ * ## Why they live in `@sneat/core`
+ *
+ * The instances themselves are created by `provideSneatFirebase()` in
+ * `@sneat/app-auth`, which sits at the *top* of the dependency graph — it
+ * depends on `@sneat/auth-core`, `@sneat/logging` and `@sneat/api-*`. Those
+ * lower libs are the ones that need to *inject* Auth/App/Analytics
+ * (`SneatAuthStateService`, `FirebaseSneatApiAuthAdapter`, the analytics
+ * fan-out), so declaring the tokens in `@sneat/app-auth` would make every one
+ * of them import their own dependent — a cycle nx's
+ * `enforce-module-boundaries` rejects.
+ *
+ * `@sneat/core` is the one lib every consumer already depends on, and it
+ * already owns the matching `IFirebaseConfig`/`FirebaseConfigToken`
+ * declarations, so the tokens belong here. `@sneat/app-auth` re-exports all
+ * three, so `import { SNEAT_FIREBASE_AUTH } from '@sneat/app-auth'` — the
+ * import path documented when these tokens shipped — keeps working unchanged.
+ *
+ * ## Why the firebase imports are type-only
+ *
+ * `FirebaseApp`, `Auth` and `Analytics` are interfaces in the modular SDK, so
+ * `import type` erases completely at compile time. `@sneat/core` therefore
+ * gains **no** runtime dependency on `firebase` from this file — the peer is
+ * declared optional for exactly that reason.
+ */
+/**
+ * DI token for the app's initialized `firebase/app` `FirebaseApp` instance.
+ *
+ * `FirebaseApp` is a plain interface in the modular SDK (no runtime class),
+ * so — unlike `Firestore` — it cannot be used as an injection token by
+ * itself; inject this token instead, e.g. `inject(SNEAT_FIREBASE_APP)`.
+ */
+export declare const SNEAT_FIREBASE_APP: InjectionToken<FirebaseApp>;
+/**
+ * DI token for the app's initialized `firebase/auth` `Auth` instance.
+ * Same rationale as `SNEAT_FIREBASE_APP`: `Auth` is interface-only upstream.
+ */
+export declare const SNEAT_FIREBASE_AUTH: InjectionToken<Auth>;
+/**
+ * DI token for the app's `firebase/analytics` `Analytics` instance.
+ *
+ * Resolves to `null` — never throws — when analytics isn't configured (no
+ * real `measurementId`, using the fleet's `'G-PROVIDE_IF_NEEDED'` sentinel)
+ * or when `getAnalytics()` throws in an environment that doesn't support it
+ * (SSR, some webviews, privacy-hardened browsers). The factory only runs the
+ * first time something actually injects this token, so an app that never
+ * injects it never pays for Analytics initialization at all — consumers must
+ * treat the value as optional either way.
+ */
+export declare const SNEAT_FIREBASE_ANALYTICS: InjectionToken<Analytics | null>;

package/lib/index.d.ts

@@ -21,3 +21,4 @@ export * from './directives';
 export * from './environment-config';
 export * from './logging/interfaces';
 export * from './analytics.interface';
+export * from './firebase.tokens';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sneat/core",
-  "version": "0.26.6",
+  "version": "0.27.0",
   "publishConfig": {
     "access": "public"
   },
@@ -10,12 +10,18 @@
     "@angular/core": ">=22.0.0 <23.0.0",
     "@angular/router": ">=22.0.0 <23.0.0",
     "@ionic/angular": ">=9.0.0 <10.0.0",
-    "@sneat/core-public": "^0.26.0",
+    "@sneat/core-public": "^0.27.0",
+    "firebase": "*",
     "rxjs": ">=7.8.0"
   },
   "dependencies": {
     "tslib": "2.8.1"
   },
+  "peerDependenciesMeta": {
+    "firebase": {
+      "optional": true
+    }
+  },
   "module": "esm2022/sneat-core.js",
   "typings": "sneat-core.d.ts",
   "exports": {