@reactionary/source 0.6.2 → 0.6.3

package/{providers → packages}/fake/src/schema/capabilities.schema.ts

@@ -2,47 +2,47 @@ import type {
   Cache,
   CartFactory,
   CartFactoryWithOutput,
-  CartProvider,
+  CartCapability,
   CategoryFactory,
   CategoryFactoryWithOutput,
-  CategoryProvider,
+  CategoryCapability,
   CheckoutFactory,
   CheckoutFactoryWithOutput,
-  CheckoutProvider,
+  CheckoutCapability,
   IdentityFactory,
   IdentityFactoryWithOutput,
-  IdentityProvider,
+  IdentityCapability,
   InventoryFactory,
   InventoryFactoryWithOutput,
-  InventoryProvider,
+  InventoryCapability,
   OrderFactory,
   OrderFactoryWithOutput,
-  OrderProvider,
+  OrderCapability,
   OrderSearchFactory,
   OrderSearchFactoryWithOutput,
-  OrderSearchProvider,
+  OrderSearchCapability,
   PriceFactory,
   PriceFactoryWithOutput,
-  PriceProvider,
+  PriceCapability,
   ProductAssociationsFactory,
   ProductAssociationsFactoryWithOutput,
-  ProductAssociationsProvider,
+  ProductAssociationsCapability,
   ProductFactory,
   ProductFactoryWithOutput,
-  ProductProvider,
+  ProductCapability,
   ProductReviewsFactory,
   ProductReviewsFactoryWithOutput,
-  ProductReviewsProvider,
+  ProductReviewsCapability,
   ProductSearchFactory,
   ProductSearchFactoryWithOutput,
-  ProductSearchProvider,
+  ProductSearchCapability,
   ProfileFactory,
   ProfileFactoryWithOutput,
-  ProfileProvider,
+  ProfileCapability,
   RequestContext,
   StoreFactory,
   StoreFactoryWithOutput,
-  StoreProvider,
+  StoreCapability,
 } from '@reactionary/core';
 import { CapabilitiesSchema } from '@reactionary/core';
 import type { FakeConfiguration } from './configuration.schema.js';
@@ -51,7 +51,7 @@ import * as z from 'zod';
 const OverridableCapabilitySchema = z.looseObject({
   enabled: z.boolean(),
   factory: z.unknown().optional(),
-  provider: z.unknown().optional(),
+  capability: z.unknown().optional(),
 });
 
 export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
@@ -88,74 +88,74 @@ export const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
   })
   .partial();
 
-export interface FakeCapabilityProviderFactoryArgs<TFactory> {
+export interface FakeCapabilityFactoryArgs<TFactory> {
   cache: Cache;
   context: RequestContext;
   config: FakeConfiguration;
   factory: TFactory;
 }
 
-export interface FakeCapabilityConfig<TFactory, TProvider> {
+export interface FakeCapabilityConfig<TFactory, TCapability> {
   enabled: boolean;
   factory?: TFactory;
-  provider?: (args: FakeCapabilityProviderFactoryArgs<TFactory>) => TProvider;
+  capability?: (args: FakeCapabilityFactoryArgs<TFactory>) => TCapability;
 }
 
 export type FakeProductCapabilityConfig = FakeCapabilityConfig<
   ProductFactoryWithOutput<ProductFactory>,
-  ProductProvider
+  ProductCapability
 >;
 export type FakeProductSearchCapabilityConfig = FakeCapabilityConfig<
   ProductSearchFactoryWithOutput<ProductSearchFactory>,
-  ProductSearchProvider
+  ProductSearchCapability
 >;
 export type FakeIdentityCapabilityConfig = FakeCapabilityConfig<
   IdentityFactoryWithOutput<IdentityFactory>,
-  IdentityProvider
+  IdentityCapability
 >;
 export type FakeCategoryCapabilityConfig = FakeCapabilityConfig<
   CategoryFactoryWithOutput<CategoryFactory>,
-  CategoryProvider
+  CategoryCapability
 >;
 export type FakeCartCapabilityConfig = FakeCapabilityConfig<
   CartFactoryWithOutput<CartFactory>,
-  CartProvider
+  CartCapability
 >;
 export type FakeInventoryCapabilityConfig = FakeCapabilityConfig<
   InventoryFactoryWithOutput<InventoryFactory>,
-  InventoryProvider
+  InventoryCapability
 >;
 export type FakeStoreCapabilityConfig = FakeCapabilityConfig<
   StoreFactoryWithOutput<StoreFactory>,
-  StoreProvider
+  StoreCapability
 >;
 export type FakePriceCapabilityConfig = FakeCapabilityConfig<
   PriceFactoryWithOutput<PriceFactory>,
-  PriceProvider
+  PriceCapability
 >;
 export type FakeCheckoutCapabilityConfig = FakeCapabilityConfig<
   CheckoutFactoryWithOutput<CheckoutFactory>,
-  CheckoutProvider
+  CheckoutCapability
 >;
 export type FakeOrderCapabilityConfig = FakeCapabilityConfig<
   OrderFactoryWithOutput<OrderFactory>,
-  OrderProvider
+  OrderCapability
 >;
 export type FakeOrderSearchCapabilityConfig = FakeCapabilityConfig<
   OrderSearchFactoryWithOutput<OrderSearchFactory>,
-  OrderSearchProvider
+  OrderSearchCapability
 >;
 export type FakeProfileCapabilityConfig = FakeCapabilityConfig<
   ProfileFactoryWithOutput<ProfileFactory>,
-  ProfileProvider
+  ProfileCapability
 >;
 export type FakeProductReviewsCapabilityConfig = FakeCapabilityConfig<
   ProductReviewsFactoryWithOutput<ProductReviewsFactory>,
-  ProductReviewsProvider
+  ProductReviewsCapability
 >;
 export type FakeProductAssociationsCapabilityConfig = FakeCapabilityConfig<
   ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>,
-  ProductAssociationsProvider
+  ProductAssociationsCapability
 >;
 
 export type FakeCapabilities = {

package/{providers/fake/src/test/cart.provider.spec.ts → packages/fake/src/test/cart.capability.spec.ts}

@@ -8,8 +8,8 @@ import {
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeCartProvider } from '../providers/cart.provider.js';
-import { FakeIdentityProvider } from '../providers/index.js';
+import { FakeCartCapability } from '../capabilities/cart.capability.js';
+import { FakeIdentityCapability } from '../capabilities/index.js';
 import { FakeCartFactory, FakeIdentityFactory } from '../factories/index.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
@@ -19,19 +19,19 @@ const testData = {
 }
 
 describe('Fake Cart Provider', () => {
-  let provider: FakeCartProvider;
-  let identityProvider: FakeIdentityProvider;
+  let provider: FakeCartCapability;
+  let identityProvider: FakeIdentityCapability;
   let reqCtx: RequestContext;
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeCartProvider(
+    provider = new FakeCartCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
       reqCtx,
       new FakeCartFactory(CartSchema, CartIdentifierSchema),
     );
-    identityProvider = new FakeIdentityProvider(
+    identityProvider = new FakeIdentityCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
       reqCtx,

package/{providers/fake/src/test/category.provider.spec.ts → packages/fake/src/test/category.capability.spec.ts}

@@ -6,13 +6,13 @@ import {
   MemoryCache,
   createInitialRequestContext,
 } from '@reactionary/core';
-import { FakeCategoryProvider } from '../providers/index.js';
+import { FakeCategoryCapability } from '../capabilities/index.js';
 import { FakeCategoryFactory } from '../factories/index.js';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
 
 describe('Faker Category Provider', () => {
-  let provider: FakeCategoryProvider;
+  let provider: FakeCategoryCapability;
   let reqCtx: RequestContext;
   const cache = new MemoryCache();
 
@@ -20,7 +20,7 @@ describe('Faker Category Provider', () => {
     reqCtx = createInitialRequestContext();
     cache.clear();
 
-    provider = new FakeCategoryProvider(
+    provider = new FakeCategoryCapability(
       getFakerTestConfiguration(),
       cache,
       reqCtx,

package/{providers/fake/src/test/checkout.provider.spec.ts → packages/fake/src/test/checkout.capability.spec.ts}

@@ -9,16 +9,16 @@ import {
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import { FakeCheckoutCapability } from '../capabilities/checkout.capability.js';
 import { FakeCheckoutFactory } from '../factories/index.js';
 
 describe('Fake Checkout Provider', () => {
-  let provider: FakeCheckoutProvider;
+  let provider: FakeCheckoutCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeCheckoutProvider(
+    provider = new FakeCheckoutCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
       reqCtx,

package/{providers/fake/src/test/order-search.provider.spec.ts → packages/fake/src/test/order-search.capability.spec.ts}

@@ -7,16 +7,16 @@ import {
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
-import { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
+import { FakeOrderSearchCapability } from '../capabilities/order-search.capability.js';
 import { FakeOrderSearchFactory } from '../factories/index.js';
 
 describe('Fake Order Search Provider', () => {
-  let provider: FakeOrderSearchProvider;
+  let provider: FakeOrderSearchCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeOrderSearchProvider(
+    provider = new FakeOrderSearchCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
       reqCtx,

package/{providers/fake/src/test/order.provider.spec.ts → packages/fake/src/test/order.capability.spec.ts}

@@ -7,16 +7,16 @@ import {
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
-import { FakeOrderProvider } from '../providers/order.provider.js';
+import { FakeOrderCapability } from '../capabilities/order.capability.js';
 import { FakeOrderFactory } from '../factories/index.js';
 
 describe('Fake Order Provider', () => {
-  let provider: FakeOrderProvider;
+  let provider: FakeOrderCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeOrderProvider(
+    provider = new FakeOrderCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
       reqCtx,

package/{providers/fake/src/test/price.provider.spec.ts → packages/fake/src/test/price.capability.spec.ts}

@@ -6,7 +6,7 @@ import {
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakePriceProvider } from '../providers/price.provider.js';
+import { FakePriceCapability } from '../capabilities/price.capability.js';
 import { FakePriceFactory } from '../factories/index.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 
@@ -16,12 +16,12 @@ const testData = {
 };
 
 describe('Fake Price Provider', () => {
-  let provider: FakePriceProvider;
+  let provider: FakePriceCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakePriceProvider(
+    provider = new FakePriceCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
       reqCtx,

package/{providers/fake/src/test/product.provider.spec.ts → packages/fake/src/test/product.capability.spec.ts}

@@ -3,17 +3,17 @@ import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import { createInitialRequestContext, MemoryCache, ProductSchema } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeProductProvider } from '../providers/index.js';
+import { FakeProductCapability } from '../capabilities/index.js';
 import { FakeProductFactory } from '../factories/index.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 
 describe('Fake Product Provider', () => {
-  let provider: FakeProductProvider;
+  let provider: FakeProductCapability;
   let reqCtx: RequestContext;
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeProductProvider(
+    provider = new FakeProductCapability(
       getFakerTestConfiguration(),
       new MemoryCache(),
       reqCtx,

package/{providers/fake/src/test/profile.provider.spec.ts → packages/fake/src/test/profile.capability.spec.ts}

@@ -3,16 +3,16 @@ import type { RequestContext } from '@reactionary/core';
 import { NoOpCache, ProfileSchema, createInitialRequestContext } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
-import { FakeProfileProvider } from '../providers/profile.provider.js';
+import { FakeProfileCapability } from '../capabilities/profile.capability.js';
 import { FakeProfileFactory } from '../factories/index.js';
 
 describe('Fake Profile Provider', () => {
-  let provider: FakeProfileProvider;
+  let provider: FakeProfileCapability;
   let reqCtx: RequestContext;
 
   beforeEach(() => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeProfileProvider(
+    provider = new FakeProfileCapability(
       getFakerTestConfiguration(),
       new NoOpCache(),
       reqCtx,

package/{providers/commercetools → packages/fake}/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "NodeNext",
+    "module": "nodenext",
     "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,

package/packages/fake/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/packages/fake/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/packages/fake/vite.config.ts

@@ -0,0 +1,26 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: import.meta.dirname,
+  cacheDir: '../../node_modules/.vite/packages/fake',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  test: {
+    name: 'fake',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/fake',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/fake/vitest.config.mts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/fake',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'fake',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/fake',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/google-analytics/eslint.config.mjs

@@ -0,0 +1,23 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
+            '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+            '{projectRoot}/vite.config.{js,ts,mjs,mts}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/{providers → packages}/google-analytics/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@reactionary/google-analytics",
   "version": "0.0.1",
-  "main": "index.js",
-  "types": "src/index.d.ts",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
   "dependencies": {
     "@reactionary/core": "0.0.1",
-    "zod": "4.1.9"
+    "zod": "4.1.9",
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5"
   },
-  "type": "module",
-  "sideEffects": false
+  "sideEffets": false
 }

package/{providers → packages}/google-analytics/project.json

@@ -1,7 +1,7 @@
 {
   "name": "google-analytics",
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "providers/google-analytics/src",
+  "sourceRoot": "packages/google-analytics/src",
   "projectType": "library",
   "release": {
     "version": {
@@ -16,10 +16,10 @@
       "executor": "@nx/esbuild:esbuild",
       "outputs": ["{options.outputPath}"],
       "options": {
-        "outputPath": "dist/providers/google-analytics",
-        "main": "providers/google-analytics/src/index.ts",
-        "tsConfig": "providers/google-analytics/tsconfig.lib.json",
-        "assets": ["providers/google-analytics/*.md"],
+        "outputPath": "dist/packages/google-analytics",
+        "main": "packages/google-analytics/src/index.ts",
+        "tsConfig": "packages/google-analytics/tsconfig.lib.json",
+        "assets": ["packages/google-analytics/*.md"],
         "format": ["esm"],
         "bundle": false
       }

package/{providers/google-analytics/src/providers/analytics.provider.ts → packages/google-analytics/src/capabilities/analytics.capability.ts}

@@ -1,5 +1,5 @@
 import {
-  AnalyticsProvider,
+  AnalyticsCapability,
   type RequestContext,
   type Cache,
   type AnalyticsMutationProductSummaryViewEvent,
@@ -10,7 +10,7 @@ import {
 } from '@reactionary/core';
 import type { GoogleAnalyticsConfiguration } from '../schema/configuration.schema.js';
 
-export class GoogleAnalyticsAnalyticsProvider extends AnalyticsProvider {
+export class GoogleAnalyticsAnalyticsCapability extends AnalyticsCapability {
   protected config: GoogleAnalyticsConfiguration;
 
   constructor(

package/{providers → packages}/google-analytics/src/core/initialize.ts

@@ -4,10 +4,10 @@ import {
   type GoogleAnalyticsCapabilities,
 } from '../schema/capabilities.schema.js';
 import type { GoogleAnalyticsConfiguration } from '../schema/configuration.schema.js';
-import { GoogleAnalyticsAnalyticsProvider } from '../providers/analytics.provider.js';
+import { GoogleAnalyticsAnalyticsCapability } from '../capabilities/analytics.capability.js';
 import {
   type GoogleAnalyticsClientFromCapabilities,
-  resolveProviderOnlyCapability,
+  resolveDirectCapability,
 } from './initialize.types.js';
 
 export function withGoogleAnalyticsCapabilities<
@@ -22,9 +22,9 @@ export function withGoogleAnalyticsCapabilities<
     const caps = GoogleAnalyticsCapabilitiesSchema.parse(capabilities);
 
     if (caps.analytics?.enabled) {
-      client.analytics = resolveProviderOnlyCapability(
+      client.analytics = resolveDirectCapability(
         capabilities.analytics,
-        (args) => new GoogleAnalyticsAnalyticsProvider(args.cache, args.context, args.config),
+        (args) => new GoogleAnalyticsAnalyticsCapability(args.cache, args.context, args.config),
         {
           cache,
           context,

package/packages/google-analytics/src/core/initialize.types.ts

@@ -0,0 +1,47 @@
+import type { ClientFromCapabilities } from '@reactionary/core';
+import type { GoogleAnalyticsCapabilities } from '../schema/capabilities.schema.js';
+import type { GoogleAnalyticsAnalyticsCapability } from '../capabilities/analytics.capability.js';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends GoogleAnalyticsCapabilities> =
+  Omit<T, 'analytics'> & {
+    analytics?: EnabledCapability<T['analytics']>;
+  };
+
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> =
+  TCapability extends { enabled: true; capability?: infer TCapabilityFactory }
+    ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability
+      ? TResolvedCapability
+      : TDefaultCapability
+    : TDefaultCapability;
+
+type CapabilityOverride<
+  TCapability,
+  TKey extends string,
+  TResolvedCapability,
+> = TCapability extends { enabled: true }
+  ? { [K in TKey]: TResolvedCapability }
+  : Record<never, never>;
+
+type AnalyticsCapabilityFor<T extends GoogleAnalyticsCapabilities> =
+  ExtractCapabilityImplementation<T['analytics'], GoogleAnalyticsAnalyticsCapability>;
+
+export type GoogleAnalyticsClientFromCapabilities<
+  T extends GoogleAnalyticsCapabilities,
+> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, 'analytics'> &
+  CapabilityOverride<T['analytics'], 'analytics', AnalyticsCapabilityFor<T>>;
+
+export function resolveDirectCapability<TResolvedCapability, TCapabilityArgs>(
+  capability:
+    | {
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
+      }
+    | undefined,
+  defaultCapability: (args: TCapabilityArgs) => TResolvedCapability,
+  args: TCapabilityArgs,
+): TResolvedCapability {
+  const capabilityFactory = capability?.capability ?? defaultCapability;
+  return capabilityFactory(args);
+}

package/{providers → packages}/google-analytics/src/index.ts

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