joopjs 2.0.0

package/dist/index-DFqEoX_l.d.ts

@@ -0,0 +1,202 @@
+import './config.service-CrCvI-JS.js';
+import { e as JoopLoggerConfig } from './config.models-Cqg04fAQ.js';
+import { J as JoopObservable } from './index-Dz0gOur2.js';
+
+interface JoopLogEntry {
+    level: 'debug' | 'log' | 'info' | 'warn' | 'error' | 'off' | 'all';
+    message: any;
+    timestamp?: string;
+    component?: string;
+}
+interface JoopLoggerOptions {
+    color?: string;
+    componentName?: string;
+    isDateEnabled?: boolean;
+}
+
+declare class JoopLogger {
+    private readonly _logSubject;
+    private _config;
+    configure(config: JoopLoggerConfig): void;
+    debug(message: any, options?: JoopLoggerOptions): void;
+    log(message: any, options?: JoopLoggerOptions): void;
+    info(message: any, options?: JoopLoggerOptions): void;
+    warn(message: any, options?: JoopLoggerOptions): void;
+    error(message: any, options?: JoopLoggerOptions): void;
+    /** Subscribe to all log entries (useful for remote logging). */
+    onLog(listener: (entry: JoopLogEntry) => void): () => void;
+    private _shouldLog;
+    private _emit;
+    private _serialize;
+}
+/** Singleton logger instance exported for direct use. */
+declare const logger: JoopLogger;
+
+interface JoopPlugin {
+    name: string;
+    version?: string;
+    install(context: Record<string, unknown>): void | Promise<void>;
+    uninstall?(): void;
+}
+declare class JoopPluginService {
+    private _plugins;
+    private _context;
+    setContext(ctx: Record<string, unknown>): void;
+    use(plugin: JoopPlugin): Promise<void>;
+    unuse(name: string): void;
+    has(name: string): boolean;
+    getAll(): JoopPlugin[];
+    unuseAll(): void;
+}
+
+type JoopEnvironmentName = 'development' | 'staging' | 'production' | string;
+interface JoopEnvironmentProfile {
+    name: JoopEnvironmentName;
+    apiBaseUrl: string;
+    features?: Record<string, boolean>;
+    [key: string]: unknown;
+}
+declare class JoopEnvironmentService {
+    private _current;
+    private _profiles;
+    register(profile: JoopEnvironmentProfile): void;
+    activate(name: JoopEnvironmentName): void;
+    detect(): JoopEnvironmentName;
+    get current(): JoopEnvironmentProfile;
+    get name(): JoopEnvironmentName;
+    get apiBaseUrl(): string;
+    isDev(): boolean;
+    isStaging(): boolean;
+    isProduction(): boolean;
+    isFeatureEnabled(feature: string): boolean;
+    get<T>(key: string): T | undefined;
+}
+
+interface JoopHealthCheckResult {
+    name: string;
+    healthy: boolean;
+    latencyMs: number;
+    error?: string;
+    timestamp: number;
+}
+interface JoopHealthCheck {
+    name: string;
+    check: () => Promise<boolean>;
+    timeoutMs?: number;
+}
+declare class JoopHealthService {
+    private _checks;
+    register(check: JoopHealthCheck): void;
+    runAll(): Promise<JoopHealthCheckResult[]>;
+    run(name: string): Promise<JoopHealthCheckResult | null>;
+    pingUrl(url: string, timeoutMs?: number): Promise<JoopHealthCheckResult>;
+    private _run;
+}
+
+interface JoopFlagDefinition {
+    key: string;
+    enabled: boolean;
+    variant?: string;
+    description?: string;
+    /** Percentage rollout 0–100 — compared against a stable user hash */
+    rolloutPercent?: number;
+    /** Only enable for specific user IDs */
+    allowedUsers?: string[];
+    /** Only enable for specific environments */
+    environments?: string[];
+}
+interface JoopFlagContext {
+    userId?: string;
+    environment?: string;
+    attributes?: Record<string, unknown>;
+}
+declare class JoopFeatureFlagService {
+    private _flags;
+    private _overrides;
+    private _context;
+    private _flags$;
+    /** Register flag definitions */
+    define(flags: JoopFlagDefinition[]): void;
+    /** Load flags from a remote JSON endpoint */
+    loadFromUrl(url: string): Promise<void>;
+    /** Set user/environment context for targeting */
+    setContext(ctx: JoopFlagContext): void;
+    /** Check if a feature flag is enabled for the current context */
+    isEnabled(key: string, context?: JoopFlagContext): boolean;
+    /** Get the variant string for a flag */
+    getVariant(key: string, context?: JoopFlagContext): string | null;
+    /** Override a flag locally (for testing) */
+    setOverride(key: string, value: boolean): void;
+    clearOverrides(): void;
+    getAllFlags(): JoopFlagDefinition[];
+    getFlag(key: string): JoopFlagDefinition | undefined;
+    flags$(): JoopObservable<Map<string, JoopFlagDefinition>>;
+    /** Simple deterministic hash for percentage rollouts */
+    private _hash;
+}
+
+interface JoopTokenBucketConfig {
+    capacity: number;
+    refillRate: number;
+}
+declare class JoopTokenBucket {
+    private _tokens;
+    private _lastRefill;
+    private readonly _cap;
+    private readonly _rate;
+    constructor(config: JoopTokenBucketConfig);
+    private _refill;
+    /** Returns true if tokens were available and consumed */
+    consume(tokens?: number): boolean;
+    /** Waits until enough tokens are available, then consumes */
+    tryConsume(tokens?: number): Promise<void>;
+    available(): number;
+    reset(): void;
+}
+declare class JoopRateLimiter {
+    private _buckets;
+    private _timers;
+    /** Create or get a token bucket by key */
+    bucket(key: string, config?: JoopTokenBucketConfig): JoopTokenBucket;
+    deleteBucket(key: string): void;
+    /** Returns a throttled version — at most once per delayMs */
+    throttle<T extends unknown[]>(fn: (...args: T) => void, delayMs: number): (...args: T) => void;
+    /** Returns a debounced version — fires after delayMs of silence */
+    debounce<T extends unknown[]>(fn: (...args: T) => void, delayMs: number, immediate?: boolean): (...args: T) => void;
+    /** Promise-based debounce — resolves when the debounced call fires */
+    debounceAsync<T>(fn: () => Promise<T>, delayMs: number): () => Promise<T>;
+    /** Ensure a function is called at most once per key in the given window */
+    once(key: string, fn: () => void, windowMs: number): boolean;
+}
+
+type JoopConsentCategory = 'necessary' | 'analytics' | 'marketing' | 'functional' | 'personalization';
+interface JoopConsentState {
+    decided: boolean;
+    categories: Record<JoopConsentCategory, boolean>;
+    timestamp: number | null;
+}
+declare class JoopConsentService {
+    private _state$;
+    constructor(storageKey?: string);
+    private _key;
+    private _loadFrom;
+    /** Grant one or more categories */
+    grant(categories: JoopConsentCategory | JoopConsentCategory[]): void;
+    /** Revoke one or more categories (cannot revoke 'necessary') */
+    revoke(categories: JoopConsentCategory | JoopConsentCategory[]): void;
+    /** Grant all categories at once */
+    acceptAll(): void;
+    /** Reject all non-necessary categories */
+    rejectAll(): void;
+    isGranted(category: JoopConsentCategory): boolean;
+    hasDecided(): boolean;
+    getAll(): Record<JoopConsentCategory, boolean>;
+    getState(): JoopConsentState;
+    state$(): JoopObservable<JoopConsentState>;
+    reset(): void;
+    onChange(handler: (state: JoopConsentState) => void): () => void;
+    onCategoryChange(category: JoopConsentCategory, handler: (granted: boolean) => void): () => void;
+    private _persist;
+}
+
+export { JoopLogger as J, JoopPluginService as a, JoopEnvironmentService as b, JoopHealthService as c, JoopFeatureFlagService as d, JoopRateLimiter as e, JoopConsentService as f, type JoopConsentCategory as g, type JoopConsentState as h, type JoopEnvironmentName as i, type JoopEnvironmentProfile as j, type JoopFlagContext as k, type JoopFlagDefinition as l, type JoopHealthCheck as m, type JoopHealthCheckResult as n, type JoopLogEntry as o, type JoopLoggerOptions as p, type JoopPlugin as q, JoopTokenBucket as r, type JoopTokenBucketConfig as s, logger as t };

package/dist/index-Dz0gOur2.d.mts

@@ -0,0 +1,36 @@
+type Unsubscribe = () => void;
+type Listener<T> = (value: T) => void;
+/**
+ * Lightweight pub/sub subject — emits to all current subscribers.
+ * Replaces RxJS Subject without pulling in the full RxJS dependency.
+ */
+declare class JoopSubject<T> {
+    private _listeners;
+    subscribe(listener: Listener<T>): Unsubscribe;
+    next(value: T): void;
+    asObservable(): JoopObservable<T>;
+}
+/**
+ * Stateful subject — replays the current value to any new subscriber immediately.
+ * Replaces RxJS BehaviorSubject.
+ */
+declare class JoopBehaviorSubject<T> extends JoopSubject<T> {
+    private _value;
+    constructor(initialValue: T);
+    getValue(): T;
+    next(value: T): void;
+    subscribe(listener: Listener<T>): Unsubscribe;
+    asObservable(): JoopObservable<T>;
+}
+/**
+ * Read-only observable handle returned from asObservable().
+ */
+declare class JoopObservable<T> {
+    private _subscribeFn;
+    constructor(_subscribeFn: (listener: Listener<T>) => Unsubscribe);
+    subscribe(listener: Listener<T>): Unsubscribe;
+    /** Returns the current value without subscribing (only meaningful for BehaviorSubject-backed observables). */
+    getOnce(): T | undefined;
+}
+
+export { JoopObservable as J, type Listener as L, type Unsubscribe as U, JoopBehaviorSubject as a, JoopSubject as b };

package/dist/index-Dz0gOur2.d.ts

@@ -0,0 +1,36 @@
+type Unsubscribe = () => void;
+type Listener<T> = (value: T) => void;
+/**
+ * Lightweight pub/sub subject — emits to all current subscribers.
+ * Replaces RxJS Subject without pulling in the full RxJS dependency.
+ */
+declare class JoopSubject<T> {
+    private _listeners;
+    subscribe(listener: Listener<T>): Unsubscribe;
+    next(value: T): void;
+    asObservable(): JoopObservable<T>;
+}
+/**
+ * Stateful subject — replays the current value to any new subscriber immediately.
+ * Replaces RxJS BehaviorSubject.
+ */
+declare class JoopBehaviorSubject<T> extends JoopSubject<T> {
+    private _value;
+    constructor(initialValue: T);
+    getValue(): T;
+    next(value: T): void;
+    subscribe(listener: Listener<T>): Unsubscribe;
+    asObservable(): JoopObservable<T>;
+}
+/**
+ * Read-only observable handle returned from asObservable().
+ */
+declare class JoopObservable<T> {
+    private _subscribeFn;
+    constructor(_subscribeFn: (listener: Listener<T>) => Unsubscribe);
+    subscribe(listener: Listener<T>): Unsubscribe;
+    /** Returns the current value without subscribing (only meaningful for BehaviorSubject-backed observables). */
+    getOnce(): T | undefined;
+}
+
+export { JoopObservable as J, type Listener as L, type Unsubscribe as U, JoopBehaviorSubject as a, JoopSubject as b };