@reactionary/google-analytics 0.6.1 → 0.6.2

package/core/initialize.js

@@ -1,13 +1,30 @@
+import {
+  GoogleAnalyticsCapabilitiesSchema
+} from "../schema/capabilities.schema.js";
 import { GoogleAnalyticsAnalyticsProvider } from "../providers/analytics.provider.js";
-function googleAnalyticsCapabilities(configuration, capabilities) {
+import {
+  resolveProviderOnlyCapability
+} from "./initialize.types.js";
+function withGoogleAnalyticsCapabilities(configuration, capabilities) {
   return (cache, context) => {
     const client = {};
-    if (capabilities.analytics) {
-      client.analytics = new GoogleAnalyticsAnalyticsProvider(cache, context, configuration);
+    const caps = GoogleAnalyticsCapabilitiesSchema.parse(capabilities);
+    if (caps.analytics?.enabled) {
+      client.analytics = resolveProviderOnlyCapability(
+        capabilities.analytics,
+        (args) => new GoogleAnalyticsAnalyticsProvider(args.cache, args.context, args.config),
+        {
+          cache,
+          context,
+          config: configuration
+        }
+      );
     }
     return client;
   };
 }
+const googleAnalyticsCapabilities = withGoogleAnalyticsCapabilities;
 export {
-  googleAnalyticsCapabilities
+  googleAnalyticsCapabilities,
+  withGoogleAnalyticsCapabilities
 };

package/core/initialize.types.js

@@ -0,0 +1,7 @@
+function resolveProviderOnlyCapability(capability, defaultProvider, args) {
+  const provider = capability?.provider ?? defaultProvider;
+  return provider(args);
+}
+export {
+  resolveProviderOnlyCapability
+};

package/index.js

@@ -1,4 +1,5 @@
 export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
 export * from "./providers/analytics.provider.js";
 export * from "./schema/capabilities.schema.js";
 export * from "./schema/configuration.schema.js";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@reactionary/google-analytics",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.6.1",
+    "@reactionary/core": "0.6.2",
     "zod": "4.1.9"
   },
   "type": "module",

package/schema/capabilities.schema.js

@@ -1,6 +1,13 @@
 import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const AnalyticsCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  provider: z.unknown().optional()
+});
 const GoogleAnalyticsCapabilitiesSchema = CapabilitiesSchema.pick({
   analytics: true
+}).extend({
+  analytics: AnalyticsCapabilitySchema.optional()
 }).partial();
 export {
   GoogleAnalyticsCapabilitiesSchema

package/src/core/initialize.d.ts

@@ -1,4 +1,6 @@
-import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
-import type { GoogleAnalyticsCapabilities } from "../schema/capabilities.schema.js";
-import type { GoogleAnalyticsConfiguration } from "../schema/configuration.schema.js";
-export declare function googleAnalyticsCapabilities<T extends GoogleAnalyticsCapabilities>(configuration: GoogleAnalyticsConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => ClientFromCapabilities<T>;
+import type { Cache, RequestContext } from '@reactionary/core';
+import { type GoogleAnalyticsCapabilities } from '../schema/capabilities.schema.js';
+import type { GoogleAnalyticsConfiguration } from '../schema/configuration.schema.js';
+import { type GoogleAnalyticsClientFromCapabilities } from './initialize.types.js';
+export declare function withGoogleAnalyticsCapabilities<T extends GoogleAnalyticsCapabilities>(configuration: GoogleAnalyticsConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => GoogleAnalyticsClientFromCapabilities<T>;
+export declare const googleAnalyticsCapabilities: typeof withGoogleAnalyticsCapabilities;

package/src/core/initialize.types.d.ts

@@ -0,0 +1,24 @@
+import type { ClientFromCapabilities } from '@reactionary/core';
+import type { GoogleAnalyticsCapabilities } from '../schema/capabilities.schema.js';
+import type { GoogleAnalyticsAnalyticsProvider } from '../providers/analytics.provider.js';
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends GoogleAnalyticsCapabilities> = Omit<T, 'analytics'> & {
+    analytics?: EnabledCapability<T['analytics']>;
+};
+type ExtractCapabilityProvider<TCapability, TDefaultProvider> = TCapability extends {
+    enabled: true;
+    provider?: infer TProviderFactory;
+} ? TProviderFactory extends (...args: unknown[]) => infer TProvider ? TProvider : TDefaultProvider : TDefaultProvider;
+type CapabilityOverride<TCapability, TKey extends string, TProvider> = TCapability extends {
+    enabled: true;
+} ? {
+    [K in TKey]: TProvider;
+} : Record<never, never>;
+type AnalyticsProviderFor<T extends GoogleAnalyticsCapabilities> = ExtractCapabilityProvider<T['analytics'], GoogleAnalyticsAnalyticsProvider>;
+export type GoogleAnalyticsClientFromCapabilities<T extends GoogleAnalyticsCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, 'analytics'> & CapabilityOverride<T['analytics'], 'analytics', AnalyticsProviderFor<T>>;
+export declare function resolveProviderOnlyCapability<TProvider, TProviderArgs>(capability: {
+    provider?: (args: TProviderArgs) => TProvider;
+} | undefined, defaultProvider: (args: TProviderArgs) => TProvider, args: TProviderArgs): TProvider;
+export {};

package/src/index.d.ts

@@ -1,4 +1,5 @@
 export * from './core/initialize.js';
+export * from './core/initialize.types.js';
 export * from './providers/analytics.provider.js';
 export * from './schema/capabilities.schema.js';
 export * from './schema/configuration.schema.js';

package/src/schema/capabilities.schema.d.ts

@@ -1,5 +1,21 @@
-import type * as z from 'zod';
+import type { AnalyticsProvider, Cache, RequestContext } from '@reactionary/core';
+import type { GoogleAnalyticsConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
 export declare const GoogleAnalyticsCapabilitiesSchema: z.ZodObject<{
-    analytics: z.ZodOptional<z.ZodBoolean>;
+    analytics: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        provider: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
-export type GoogleAnalyticsCapabilities = z.infer<typeof GoogleAnalyticsCapabilitiesSchema>;
+export interface GoogleAnalyticsProviderFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+    config: GoogleAnalyticsConfiguration;
+}
+export interface GoogleAnalyticsAnalyticsCapabilityConfig<TProvider extends AnalyticsProvider = AnalyticsProvider> {
+    enabled: boolean;
+    provider?: (args: GoogleAnalyticsProviderFactoryArgs) => TProvider;
+}
+export type GoogleAnalyticsCapabilities<TAnalyticsProvider extends AnalyticsProvider = AnalyticsProvider> = {
+    analytics?: GoogleAnalyticsAnalyticsCapabilityConfig<TAnalyticsProvider>;
+};