@plyaz/core 1.2.0 → 1.3.0

package/dist/events/CoreEventManager.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Core Event Manager
+ *
+ * Type-safe event system for the Plyaz ecosystem.
+ * Services emit events → Store, API cache, and UI subscribe independently.
+ *
+ * @example
+ * ```typescript
+ * import { CoreEventManager, CORE_EVENTS } from '@plyaz/core/events';
+ *
+ * // Type-safe emission (using CORE_EVENTS constants)
+ * CoreEventManager.emit(CORE_EVENTS.API.REQUEST_ERROR, {
+ *   method: 'GET',
+ *   url: '/api/users',
+ *   requestId: '123',
+ *   error: new Error('Failed'),
+ *   duration: 500,
+ * });
+ *
+ * // Type-safe subscription
+ * CoreEventManager.on(CORE_EVENTS.AUTH.LOGIN, (event) => {
+ *   console.log(event.data.userId); // Typed!
+ * });
+ *
+ * // Custom events (with generic type)
+ * CoreEventManager.emit<MyPayload>('custom:event', { custom: 'data' });
+ * ```
+ */
+import type { CoreEventPayloadMap, CoreEventScopeType, CoreEvent } from '@plyaz/types/core';
+declare class CoreEventManagerClass {
+    private emitter;
+    private subscriptions;
+    constructor();
+    /**
+     * Emit an event
+     *
+     * @param eventType - Event type from CORE_EVENTS or custom string
+     * @param data - Event payload (type-safe when using CORE_EVENTS)
+     *
+     * @example
+     * ```typescript
+     * // Type-safe with CORE_EVENTS
+     * CoreEventManager.emit(CORE_EVENTS.AUTH.LOGIN, { userId: '123', method: 'email' });
+     *
+     * // Custom event
+     * CoreEventManager.emit<MyPayload>('custom:event', { custom: 'data' });
+     * ```
+     */
+    emit<T extends keyof CoreEventPayloadMap>(eventType: T, data: CoreEventPayloadMap[T]): boolean;
+    emit<TData = unknown>(eventType: string, data?: TData): boolean;
+    /**
+     * Subscribe to an event
+     *
+     * @param eventType - Event type from CORE_EVENTS or custom string
+     * @param handler - Event handler (type-safe when using CORE_EVENTS)
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * // Type-safe with CORE_EVENTS
+     * const unsub = CoreEventManager.on(CORE_EVENTS.AUTH.LOGIN, (event) => {
+     *   console.log(event.data.userId); // Typed!
+     * });
+     *
+     * // Custom event
+     * CoreEventManager.on<MyPayload>('custom:event', (event) => {
+     *   console.log(event.data.custom);
+     * });
+     * ```
+     */
+    on<T extends keyof CoreEventPayloadMap>(eventType: T, handler: (event: CoreEvent<CoreEventPayloadMap[T], CoreEventScopeType>) => void): () => void;
+    on<TData = unknown, TScope extends string = string>(eventType: string, handler: (event: CoreEvent<TData, TScope>) => void): () => void;
+    /**
+     * Subscribe once to an event
+     *
+     * @param eventType - Event type from CORE_EVENTS or custom string
+     * @param handler - Event handler
+     * @returns Unsubscribe function
+     */
+    once<T extends keyof CoreEventPayloadMap>(eventType: T, handler: (event: CoreEvent<CoreEventPayloadMap[T], CoreEventScopeType>) => void): () => void;
+    once<TData = unknown, TScope extends string = string>(eventType: string, handler: (event: CoreEvent<TData, TScope>) => void): () => void;
+    /**
+     * Subscribe to all events in a scope
+     *
+     * @param scope - Event scope to listen to (e.g., CoreEventScope.AUTH)
+     * @param handler - Event handler
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * CoreEventManager.onScope(CoreEventScope.AUTH, (event) => {
+     *   // Handles auth:login, auth:logout, auth:tokenRefresh, etc.
+     *   console.log(`Auth event: ${event.type}`, event.data);
+     * });
+     * ```
+     */
+    onScope<TScope extends string = string, TData = unknown>(scope: TScope, handler: (event: CoreEvent<TData, TScope>) => void): () => void;
+    /**
+     * Remove a specific handler from an event
+     *
+     * @param eventType - Event type
+     * @param handler - Handler to remove
+     */
+    off<TData = unknown, TScope extends string = string>(eventType: string, handler: (event: CoreEvent<TData, TScope>) => void): void;
+    /**
+     * Dispose all subscriptions
+     */
+    dispose(): void;
+    /**
+     * Generate correlation ID for event tracing
+     */
+    private getCorrelationId;
+}
+export declare const CoreEventManager: CoreEventManagerClass;
+export {};
+//# sourceMappingURL=CoreEventManager.d.ts.map

package/dist/events/CoreEventManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoreEventManager.d.ts","sourceRoot":"","sources":["../../src/events/CoreEventManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAoC5F,cAAM,qBAAqB;IACzB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,aAAa,CAAuE;;IAO5F;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,mBAAmB,EAAE,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,OAAO;IAC9F,IAAI,CAAC,KAAK,GAAG,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,KAAK,GAAG,OAAO;IAoB/D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,mBAAmB,EACpC,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,KAAK,IAAI,GAC9E,MAAM,IAAI;IACb,EAAE,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,SAAS,MAAM,GAAG,MAAM,EAChD,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,GACjD,MAAM,IAAI;IAsBb;;;;;;OAMG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,mBAAmB,EACtC,SAAS,EAAE,CAAC,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC,KAAK,IAAI,GAC9E,MAAM,IAAI;IACb,IAAI,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,SAAS,MAAM,GAAG,MAAM,EAClD,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,GACjD,MAAM,IAAI;IAgCb;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,EAAE,KAAK,GAAG,OAAO,EACrD,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,GACjD,MAAM,IAAI;IASb;;;;;OAKG;IACH,GAAG,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,SAAS,MAAM,GAAG,MAAM,EACjD,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,GACjD,IAAI;IAOP;;OAEG;IACH,OAAO,IAAI,IAAI;IAQf;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAGzB;AAGD,eAAO,MAAM,gBAAgB,uBAA8B,CAAC"}

package/dist/events/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Events Module Exports
+ *
+ * Type-safe event system with enums, constants, and typed payloads.
+ *
+ * @example
+ * ```typescript
+ * import { CoreEventManager, CORE_EVENTS, CoreEventScope } from '@plyaz/core/events';
+ *
+ * // Type-safe emission (automatic with CORE_EVENTS)
+ * CoreEventManager.emit(CORE_EVENTS.AUTH.LOGIN, {
+ *   userId: '123',
+ *   method: 'email',
+ * });
+ *
+ * // Type-safe subscription (automatic with CORE_EVENTS)
+ * CoreEventManager.on(CORE_EVENTS.AUTH.LOGIN, (event) => {
+ *   console.log(event.data.userId); // Typed!
+ * });
+ *
+ * // Custom events with explicit type
+ * CoreEventManager.emit<MyPayload>('custom:event', { custom: 'data' });
+ * ```
+ */
+export { CoreEventManager } from './CoreEventManager';
+export type { CoreEventPayloadMap, CoreEventType, CoreEventScopeType, CoreSystemInitializedPayload, CoreSystemReadyPayload, CoreSystemShutdownPayload, CoreSystemErrorPayload, CoreSystemWarningPayload, CoreApiRequestStartPayload, CoreApiRequestSuccessPayload, CoreApiRequestErrorPayload, CoreApiRetryPayload, CoreApiTimeoutPayload, CoreCacheHitPayload, CoreCacheMissPayload, CoreCacheSetPayload, CoreCacheDeletePayload, CoreCacheClearPayload, CoreCacheExpiredPayload, CoreAuthLoginPayload, CoreAuthLogoutPayload, CoreAuthTokenRefreshPayload, CoreAuthSessionExpiredPayload, CoreAuthUnauthorizedPayload, CoreFeatureFlagChangedPayload, CoreFeatureFlagEvaluatedPayload, CoreFeatureFlagRefreshedPayload, CoreStoreUpdatedPayload, CoreStoreResetPayload, CoreStoreHydratedPayload, CoreEntityCreatedPayload, CoreEntityUpdatedPayload, CoreEntityDeletedPayload, CoreValidationStartedPayload, CoreValidationSuccessPayload, CoreValidationFailedPayload, } from '@plyaz/types/core';
+//# sourceMappingURL=index.d.ts.map

package/dist/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/events/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,YAAY,EACV,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAElB,4BAA4B,EAC5B,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,mBAAmB,EACnB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,2BAA2B,EAC3B,6BAA6B,EAC7B,2BAA2B,EAC3B,6BAA6B,EAC7B,+BAA+B,EAC/B,+BAA+B,EAC/B,uBAAuB,EACvB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC5B,2BAA2B,GAC5B,MAAM,mBAAmB,CAAC"}

package/dist/frontend/base/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Frontend Base Classes
+ *
+ * Base classes and interfaces for frontend domain services.
+ * Re-exports from domain/base for backward compatibility.
+ */
+export { BaseFrontendDomainService } from '../../domain/base';
+//# sourceMappingURL=index.d.ts.map

package/dist/frontend/base/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/base/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/frontend/components/InitializationError.d.ts

@@ -0,0 +1,25 @@
+/**
+ * InitializationError Component
+ *
+ * Default error display when Plyaz initialization fails.
+ * Can be overridden via the `error` prop on PlyazProvider.
+ */
+import type { ReactElement } from 'react';
+import type { CoreInitializationErrorProps as InitializationErrorProps } from '@plyaz/types/core';
+/**
+ * Renders an initialization error state.
+ *
+ * @example
+ * ```tsx
+ * // Using default error display
+ * <InitializationError error={new Error('Failed to connect')} />
+ *
+ * // Using custom error component
+ * <InitializationError
+ *   error={error}
+ *   errorComponent={(err) => <CustomErrorBoundary error={err} />}
+ * />
+ * ```
+ */
+export declare function InitializationError({ error, errorComponent, }: InitializationErrorProps): ReactElement;
+//# sourceMappingURL=InitializationError.d.ts.map

package/dist/frontend/components/InitializationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializationError.d.ts","sourceRoot":"","sources":["../../../src/frontend/components/InitializationError.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,4BAA4B,IAAI,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AA4BlG;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,KAAK,EACL,cAAc,GACf,EAAE,wBAAwB,GAAG,YAAY,CAWzC"}

package/dist/frontend/components/InitializationLoading.d.ts

@@ -0,0 +1,22 @@
+/**
+ * InitializationLoading Component
+ *
+ * Default loading display while Plyaz is initializing.
+ * Can be overridden via the `loading` prop on PlyazProvider.
+ */
+import type { ReactElement } from 'react';
+import type { CoreInitializationLoadingProps as InitializationLoadingProps } from '@plyaz/types/core';
+/**
+ * Renders an initialization loading state.
+ *
+ * @example
+ * ```tsx
+ * // Using default loading display
+ * <InitializationLoading />
+ *
+ * // Using custom loading component
+ * <InitializationLoading loading={<Skeleton />} />
+ * ```
+ */
+export declare function InitializationLoading({ loading }: InitializationLoadingProps): ReactElement;
+//# sourceMappingURL=InitializationLoading.d.ts.map

package/dist/frontend/components/InitializationLoading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitializationLoading.d.ts","sourceRoot":"","sources":["../../../src/frontend/components/InitializationLoading.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAiB,YAAY,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,8BAA8B,IAAI,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAmBtG;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,EAAE,0BAA0B,GAAG,YAAY,CAU3F"}

package/dist/frontend/components/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Frontend Components
+ *
+ * Reusable React components for Plyaz frontend.
+ * Component props types are available from @plyaz/types/core
+ */
+export { InitializationError } from './InitializationError';
+export { InitializationLoading } from './InitializationLoading';
+//# sourceMappingURL=index.d.ts.map

package/dist/frontend/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/components/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/frontend/example/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Frontend Example Exports
+ *
+ * Re-exports from domain/example.
+ *
+ * NOTE: Example store has been moved to @plyaz/store/domains/examples
+ */
+export { FrontendExampleDomainService, type ExampleFrontendStoreSlice, type ExampleFrontendStoreData, type ExampleFrontendServiceConfig, type ExampleFrontendEventType, } from '../../domain/example';
+//# sourceMappingURL=index.d.ts.map

package/dist/frontend/example/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/example/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,4BAA4B,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,4BAA4B,EACjC,KAAK,wBAAwB,GAC9B,MAAM,sBAAsB,CAAC"}

package/dist/frontend/featureFlags/index.d.ts

@@ -1,14 +1,35 @@
 /**
  * Frontend Feature Flags - Main Exports
  *
- * React-specific exports for feature flag integration.
- * This will be moved to @plyaz/core when the package structure is finalized.
+ * Service-based feature flag integration for frontend.
+ * Use PlyazProvider hooks (useFlag, useFeatureFlags, useService) for React components.
+
+ * @example
+ * ```tsx
+ * import { useFlag, useService, PlyazProvider } from '@plyaz/core/frontend';
+ * import { FeatureFlagDomainService } from '@plyaz/core/frontend/featureFlags';
+ *
+ * // Using useFlag hook (simple boolean check)
+ * function MyComponent() {
+ *   const isDarkMode = useFlag('DARK_MODE');
+ *   return <div className={isDarkMode ? 'dark' : 'light'}>...</div>;
+ * }
+ *
+ * // Using FeatureFlagDomainService (full service access)
+ * function AdvancedComponent() {
+ *   const flagService = useService<FeatureFlagDomainService>('featureFlags');
+ *
+ *   const handleEvaluate = async () => {
+ *     const result = await flagService.evaluate('FEATURE_X', { userId: '123' });
+ *     console.log('Evaluation:', result);
+ *   };
+ *
+ *   return <button onClick={handleEvaluate}>Evaluate Flag</button>;
+ * }
+ * ```
  *
  * @fileoverview Frontend feature flags exports
- * @version 1.0.0
+ * @version 2.0.0
  */
-export { FeatureFlagContext, FeatureFlagAppProvider, createFeatureFlagProvider, } from './providers/FeatureFlagProvider';
-export { useFeatureFlag, useFeatureFlagEnabled, useFeatureFlagValue, useMultipleFeatureFlags, } from './hooks/useFeatureFlag';
-export { useFeatureFlagProvider, useFeatureFlagProviderStatus, } from './hooks/useFeatureFlagProvider';
-export { useFeatureFlagHelpers } from './hooks/useFeatureFlagActions';
+export { FrontendFeatureFlagDomainService } from '../../domain/featureFlags';
 //# sourceMappingURL=index.d.ts.map

package/dist/frontend/featureFlags/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/featureFlags/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,yBAAyB,GAC1B,MAAM,iCAAiC,CAAC;AAGzC,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/featureFlags/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,EAAE,gCAAgC,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/frontend/index.d.ts

@@ -1,3 +1,7 @@
+export * from './base';
+export * from './components';
+export * from './example';
 export * from './featureFlags';
 export * from './providers';
+export * from './store';
 //# sourceMappingURL=index.d.ts.map

package/dist/frontend/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/frontend/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/frontend/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}

package/dist/frontend/providers/ApiProvider.d.ts

@@ -5,7 +5,7 @@
  * @module frontend/providers/ApiProvider
  */
 import { type ReactElement } from 'react';
-import type { ApiProviderProps } from '@plyaz/types/core';
+import type { CoreApiProviderProps } from '@plyaz/types/core';
 /**
  * API Provider Component
  * IMPORTANT: For client components, pass sensitive config from server-side props/actions
@@ -37,5 +37,5 @@ import type { ApiProviderProps } from '@plyaz/types/core';
  * }
  * ```
  */
-export declare function ApiProvider({ children, envConfig, apiConfig, loadingComponent, errorComponent, onInitialized, onError, }: ApiProviderProps): ReactElement;
+export declare function ApiProvider({ children, envConfig, apiConfig, loadingComponent, errorComponent, onInitialized, onError, }: CoreApiProviderProps): ReactElement;
 //# sourceMappingURL=ApiProvider.d.ts.map

package/dist/frontend/providers/ApiProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ApiProvider.d.ts","sourceRoot":"","sources":["../../../src/frontend/providers/ApiProvider.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAE/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,OAAO,GACR,EAAE,gBAAgB,GAAG,YAAY,CAsDjC"}
+{"version":3,"file":"ApiProvider.d.ts","sourceRoot":"","sources":["../../../src/frontend/providers/ApiProvider.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAE/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,OAAO,GACR,EAAE,oBAAoB,GAAG,YAAY,CAsDrC"}

package/dist/frontend/providers/PlyazProvider.d.ts

@@ -0,0 +1,305 @@
+/**
+ * PlyazProvider - Unified React Provider for Plyaz Core Services
+ *
+ * A single provider that initializes and provides access to all frontend-safe
+ * Plyaz services. Designed for ease of use without unnecessary limitations.
+ *
+ * @module frontend/providers/PlyazProvider
+ *
+ * @example Basic usage
+ * ```tsx
+ * import { PlyazProvider } from '@plyaz/core/frontend';
+ *
+ * export default function App({ children }) {
+ *   return (
+ *     <PlyazProvider
+ *       config={{
+ *         api: {
+ *           baseURL: process.env.NEXT_PUBLIC_API_URL!,
+ *           env: 'production',
+ *         },
+ *       }}
+ *     >
+ *       {children}
+ *     </PlyazProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example With all options
+ * ```tsx
+ * <PlyazProvider
+ *   config={{
+ *     api: {
+ *       baseURL: 'https://api.example.com',
+ *       env: 'production',
+ *       apiKey: process.env.NEXT_PUBLIC_API_KEY,
+ *     },
+ *     featureFlags: {
+ *       provider: 'api',
+ *       refreshInterval: 60000,
+ *     },
+ *     appContext: 'webapp',
+ *     verbose: process.env.NODE_ENV === 'development',
+ *   }}
+ *   onReady={(services) => console.log('Services ready:', services)}
+ *   onError={(error) => Sentry.captureException(error)}
+ *   loading={<Skeleton />}
+ *   error={(err) => <ErrorBoundary error={err} />}
+ * >
+ *   {children}
+ * </PlyazProvider>
+ * ```
+ *
+ * @example Accessing services in components
+ * ```tsx
+ * import { usePlyaz, useApi, useEvents, useFeatureFlag } from '@plyaz/core/frontend';
+ *
+ * function MyComponent() {
+ *   // Full access to all services
+ *   const { api, events, isReady } = usePlyaz();
+ *
+ *   // Or use specific hooks
+ *   const apiClient = useApi();
+ *   const events = useEvents();
+ *   const { value: darkMode } = useFeatureFlag('DARK_MODE');
+ *
+ *   // Make API calls
+ *   const fetchData = async () => {
+ *     const response = await apiClient.get('/users');
+ *     return response.data;
+ *   };
+ *
+ *   // Subscribe to events
+ *   useEffect(() => {
+ *     const unsubscribe = events.on('user:updated', (event) => {
+ *       console.log('User updated:', event.data);
+ *     });
+ *     return unsubscribe;
+ *   }, [events]);
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+import { type ReactElement } from 'react';
+import { Core } from '../../init/CoreInitializer';
+import { ApiClientService } from '../../services/ApiClientService';
+import { CoreEventManager } from '../../events/CoreEventManager';
+import type { CoreAppContext, CoreAppEnvironment, CorePlyazContextValue, CorePlyazProviderProps as PlyazProviderProps, CoreDomainServiceInstance } from '@plyaz/types/core';
+/**
+ * Implementation-specific context value.
+ * Extends CorePlyazContextValue with concrete implementation references.
+ */
+interface PlyazContextValue extends Omit<CorePlyazContextValue, 'api' | 'events' | 'core'> {
+    /** API client for making HTTP requests */
+    api: typeof ApiClientService | null;
+    /** Event manager for pub/sub */
+    events: typeof CoreEventManager;
+    /** Core initializer reference */
+    core: typeof Core;
+}
+declare const PlyazContext: import("react").Context<PlyazContextValue | null>;
+export declare function PlyazProvider({ children, config, loading, error: errorComponent, onReady, onError, skipLoadingState, }: PlyazProviderProps): ReactElement;
+/**
+ * Access all Plyaz services
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { api, events, isReady, featureFlags } = usePlyaz();
+ *
+ *   if (!isReady) return <Loading />;
+ *
+ *   const handleClick = async () => {
+ *     const response = await api.getClient().get('/data');
+ *     events.emit('data:fetched', { data: response.data });
+ *   };
+ *
+ *   return <button onClick={handleClick}>Fetch</button>;
+ * }
+ * ```
+ */
+export declare function usePlyaz(): PlyazContextValue;
+/**
+ * Access API client directly
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const api = useApi();
+ *   const [users, setUsers] = useState([]);
+ *
+ *   useEffect(() => {
+ *     api.getClient().get('/users').then(res => setUsers(res.data));
+ *   }, [api]);
+ *
+ *   return <ul>{users.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
+ * }
+ * ```
+ */
+export declare function useApi(): typeof ApiClientService;
+/**
+ * Access API client safely (returns null if not ready)
+ */
+export declare function useApiSafe(): typeof ApiClientService | null;
+/**
+ * Access event manager
+ *
+ * @example
+ * ```tsx
+ * function NotificationListener() {
+ *   const events = useEvents();
+ *
+ *   useEffect(() => {
+ *     const unsubscribe = events.on('notification:received', (event) => {
+ *       toast.show(event.data.message);
+ *     });
+ *     return unsubscribe;
+ *   }, [events]);
+ *
+ *   return null;
+ * }
+ * ```
+ */
+export declare function useEvents(): typeof CoreEventManager;
+/**
+ * Check if a feature flag is enabled
+ *
+ * @example
+ * ```tsx
+ * function FeatureComponent() {
+ *   const isEnabled = useFlag('NEW_DASHBOARD');
+ *
+ *   if (!isEnabled) return null;
+ *   return <NewDashboard />;
+ * }
+ * ```
+ */
+export declare function useFlag(key: string, defaultValue?: boolean): boolean;
+/**
+ * Access feature flag utilities
+ *
+ * @example
+ * ```tsx
+ * function FlagManager() {
+ *   const flags = useFeatureFlags();
+ *   const allFlags = flags.getAll();
+ *
+ *   return (
+ *     <div>
+ *       <pre>{JSON.stringify(allFlags, null, 2)}</pre>
+ *       <button onClick={flags.refresh}>Refresh Flags</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useFeatureFlags(): PlyazContextValue['featureFlags'];
+/**
+ * Check if Plyaz services are ready
+ *
+ * @example
+ * ```tsx
+ * function LoadingAwareComponent() {
+ *   const isReady = usePlyazReady();
+ *
+ *   if (!isReady) return <Skeleton />;
+ *   return <ActualContent />;
+ * }
+ * ```
+ */
+export declare function usePlyazReady(): boolean;
+/**
+ * Get current app context
+ */
+export declare function useAppContext(): CoreAppContext;
+/**
+ * Get current environment
+ */
+export declare function useEnvironment(): CoreAppEnvironment;
+/**
+ * Get a domain service by key.
+ * Services must be registered in the `services` config.
+ *
+ * @param key - Service key (e.g., 'featureFlags', 'example')
+ * @returns The service instance
+ * @throws If service is not initialized or not found
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const flagService = useService<FeatureFlagDomainService>('featureFlags');
+ *
+ *   useEffect(() => {
+ *     flagService.isEnabled('my-flag').then(console.log);
+ *   }, [flagService]);
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+export declare function useService<T extends CoreDomainServiceInstance = CoreDomainServiceInstance>(key: string): T;
+/**
+ * Get a domain service by key with loading state.
+ * Useful for lazy-initialized services.
+ *
+ * @param key - Service key
+ * @returns Object with service, loading state, and error
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { service, isLoading, error } = useServiceAsync<ExampleDomainService>('example');
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return <div>{service?.serviceName}</div>;
+ * }
+ * ```
+ */
+export declare function useServiceAsync<T extends CoreDomainServiceInstance = CoreDomainServiceInstance>(key: string): {
+    service: T | null;
+    isLoading: boolean;
+    error: Error | null;
+};
+/**
+ * Check if a service is registered and available
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const hasFlags = useHasService('featureFlags');
+ *
+ *   if (!hasFlags) {
+ *     return <div>Feature flags not configured</div>;
+ *   }
+ *
+ *   return <FeatureFlagUI />;
+ * }
+ * ```
+ */
+export declare function useHasService(key: string): boolean;
+/**
+ * Get all initialized service keys
+ *
+ * @example
+ * ```tsx
+ * function DebugPanel() {
+ *   const serviceKeys = useServiceKeys();
+ *
+ *   return (
+ *     <div>
+ *       <h3>Loaded Services:</h3>
+ *       <ul>
+ *         {serviceKeys.map(key => <li key={key}>{key}</li>)}
+ *       </ul>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useServiceKeys(): string[];
+export { PlyazContext };
+//# sourceMappingURL=PlyazProvider.d.ts.map

package/dist/frontend/providers/PlyazProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlyazProvider.d.ts","sourceRoot":"","sources":["../../../src/frontend/providers/PlyazProvider.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAIH,OAAO,EAOL,KAAK,YAAY,EAClB,MAAM,OAAO,CAAC;AAEf,OAAO,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAElD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAIlB,qBAAqB,EACrB,sBAAsB,IAAI,kBAAkB,EAC5C,yBAAyB,EAC1B,MAAM,mBAAmB,CAAC;AAU3B;;;GAGG;AACH,UAAU,iBAAkB,SAAQ,IAAI,CAAC,qBAAqB,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACxF,0CAA0C;IAC1C,GAAG,EAAE,OAAO,gBAAgB,GAAG,IAAI,CAAC;IACpC,gCAAgC;IAChC,MAAM,EAAE,OAAO,gBAAgB,CAAC;IAChC,iCAAiC;IACjC,IAAI,EAAE,OAAO,IAAI,CAAC;CACnB;AAkBD,QAAA,MAAM,YAAY,mDAAgD,CAAC;AA+LnE,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,MAAM,EACN,OAAO,EACP,KAAK,EAAE,cAAc,EACrB,OAAO,EACP,OAAO,EACP,gBAAwB,GACzB,EAAE,kBAAkB,GAAG,YAAY,CA4FnC;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,IAAI,iBAAiB,CAS5C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,IAAI,OAAO,gBAAgB,CAMhD;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,gBAAgB,GAAG,IAAI,CAG3D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,IAAI,OAAO,gBAAgB,CAGnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,UAAQ,GAAG,OAAO,CAGlE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,IAAI,iBAAiB,CAAC,cAAc,CAAC,CAGnE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAGvC;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,cAAc,CAG9C;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,kBAAkB,CAGnD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,yBAAyB,GAAG,yBAAyB,EACxF,GAAG,EAAE,MAAM,GACV,CAAC,CAQH;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,yBAAyB,GAAG,yBAAyB,EAC7F,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CAAE,CAmChE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAGlD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAGzC;AAMD,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/frontend/providers/index.d.ts

@@ -4,4 +4,5 @@
  * @module frontend/providers
  */
 export * from './ApiProvider';
+export * from './PlyazProvider';
 //# sourceMappingURL=index.d.ts.map

package/dist/frontend/providers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/providers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/frontend/providers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}