joopjs 2.0.0

package/dist/idempotency.service-eOKoISRD.d.ts

@@ -0,0 +1,372 @@
+import { b as JoopSubject, J as JoopObservable } from './index-Dz0gOur2.js';
+import { a as JoopHttpMethod } from './index-CqDKWTUP.js';
+import { J as JoopClientProfile } from './client-profile.service-D5bRRYQp.js';
+import { b as JoopAesService, c as JoopRequestOptions } from './aes.service-CkoupAww.js';
+import { J as JoopConfigService } from './config.service-CrCvI-JS.js';
+import { d as JoopStorageAdapter } from './adapters-B6slG6hQ.js';
+
+interface JoopFetchOptions {
+    headers?: Record<string, string>;
+    body?: any;
+    signal?: AbortSignal;
+    timeout?: number;
+}
+/**
+ * Thin fetch wrapper — no Angular, no RxJS.
+ * Use directly or extend for request/response interceptors.
+ */
+declare class JoopHttpClient {
+    request<T = any>(method: JoopHttpMethod, url: string, options?: JoopFetchOptions): Promise<T>;
+    get<T = any>(url: string, options?: JoopFetchOptions): Promise<T>;
+    post<T = any>(url: string, body?: any, options?: JoopFetchOptions): Promise<T>;
+    put<T = any>(url: string, body?: any, options?: JoopFetchOptions): Promise<T>;
+    patch<T = any>(url: string, body?: any, options?: JoopFetchOptions): Promise<T>;
+    delete<T = any>(url: string, options?: JoopFetchOptions): Promise<T>;
+    /** Upload files with progress via XMLHttpRequest (fetch does not expose upload progress). */
+    uploadWithProgress<T = any>(url: string, formData: FormData, onProgress: (percent: number) => void, headers?: Record<string, string>): Promise<T>;
+}
+
+interface JoopRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    [key: string]: unknown;
+}
+interface JoopResponse<T = unknown> {
+    status: number;
+    headers: Record<string, string>;
+    data: T;
+    url: string;
+}
+type JoopRequestInterceptor = (req: JoopRequest) => JoopRequest | Promise<JoopRequest>;
+type JoopResponseInterceptor = (res: JoopResponse) => JoopResponse | Promise<JoopResponse>;
+type JoopErrorInterceptor = (err: unknown) => unknown | Promise<unknown>;
+declare class JoopInterceptorPipeline {
+    private _req;
+    private _res;
+    private _err;
+    addRequestInterceptor(fn: JoopRequestInterceptor): () => void;
+    addResponseInterceptor(fn: JoopResponseInterceptor): () => void;
+    addErrorInterceptor(fn: JoopErrorInterceptor): () => void;
+    processRequest(req: JoopRequest): Promise<JoopRequest>;
+    processResponse(res: JoopResponse): Promise<JoopResponse>;
+    processError(err: unknown): Promise<unknown>;
+    clear(): void;
+}
+
+type JoopCircuitState = 'closed' | 'open' | 'half-open';
+type JoopCircuitBreakerState = JoopCircuitState;
+interface JoopCircuitBreakerConfig {
+    name?: string;
+    failureThreshold?: number;
+    successThreshold?: number;
+    timeoutMs?: number;
+    volumeThreshold?: number;
+    onStateChange?: (from: JoopCircuitState, to: JoopCircuitState, name: string) => void;
+}
+interface JoopCircuitBreakerStats {
+    state: JoopCircuitState;
+    failures: number;
+    successes: number;
+    totalCalls: number;
+    lastFailureAt?: number;
+    openedAt?: number;
+    nextAttemptAt?: number;
+}
+declare class JoopCircuitBreakerOpenError extends Error {
+    readonly nextAttemptAt: number;
+    constructor(name: string, nextAttemptAt: number);
+}
+declare class JoopCircuitBreaker {
+    private readonly _name;
+    private readonly failureThreshold;
+    private readonly successThreshold;
+    private readonly timeoutMs;
+    private readonly volumeThreshold;
+    private readonly onStateChangeFn?;
+    private _state;
+    private _failures;
+    private _successes;
+    private _totalCalls;
+    private _lastFailureAt?;
+    private _openedAt?;
+    constructor(nameOrConfig: string | (JoopCircuitBreakerConfig & {
+        name: string;
+    }), config?: JoopCircuitBreakerConfig);
+    get state(): JoopCircuitState;
+    get name(): string;
+    private setState;
+    private recordSuccess;
+    private recordFailure;
+    private canAttempt;
+    /** Primary execution method — throws JoopCircuitBreakerOpenError when open. */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /** Alias kept for back-compat with original `call()` interface. */
+    call<T>(fn: () => Promise<T>): Promise<T>;
+    executeWithFallback<T>(fn: () => Promise<T>, fallback: () => Promise<T> | T): Promise<T>;
+    getState(): JoopCircuitState;
+    getStats(): JoopCircuitBreakerStats;
+    reset(): void;
+    forceOpen(): void;
+    forceClose(): void;
+}
+declare class JoopCircuitBreakerRegistry {
+    private static readonly store;
+    static get(name: string, config?: JoopCircuitBreakerConfig): JoopCircuitBreaker;
+    static getAll(): Map<string, JoopCircuitBreaker>;
+    static reset(name?: string): void;
+}
+
+declare class JoopOfflineQueue {
+    private _queue;
+    private _online;
+    private _draining;
+    constructor();
+    isOnline(): boolean;
+    queueLength(): number;
+    enqueue<T>(fn: () => Promise<T>): Promise<T>;
+    drainNow(): Promise<void>;
+    clear(): void;
+    private _onOnline;
+}
+
+interface JoopPollConfig<T> {
+    fn: () => Promise<T>;
+    intervalMs: number;
+    immediate?: boolean;
+    stopWhen?: (result: T) => boolean;
+    onError?: (err: unknown) => void;
+}
+declare class JoopPollingService {
+    private _timers;
+    private _subjects;
+    start<T>(id: string, config: JoopPollConfig<T>): JoopSubject<T>;
+    stop(id: string): void;
+    stopAll(): void;
+    isPolling(id: string): boolean;
+}
+
+type JoopErrorType = 'screen' | 'popup' | 'quiet' | 'inline';
+interface JoopError {
+    status?: number;
+    title?: string;
+    message?: string;
+    description?: string;
+    icon?: string;
+    style?: string;
+    isTimeout?: boolean;
+    type?: JoopErrorType;
+    customData?: any;
+    buttons?: JoopErrorButton[];
+}
+interface JoopErrorButton {
+    label: string;
+    action?: string;
+    style?: string;
+    actionData?: any;
+}
+declare class JoopHttpError extends Error {
+    readonly statusCode: number;
+    readonly statusText: string;
+    readonly body?: any | undefined;
+    constructor(statusCode: number, statusText: string, body?: any | undefined);
+}
+declare class JoopEncryptionError extends Error {
+    constructor(message: string);
+}
+
+type JoopLoadingState = {
+    active: boolean;
+    count: number;
+};
+/**
+ * High-level service request dispatcher.
+ *
+ * - Serialises request data
+ * - Optionally encrypts (AES E2E)
+ * - Tracks concurrent requests for loader visibility
+ * - Decrypts encrypted responses
+ */
+declare class JoopRequestService {
+    private readonly _http;
+    private readonly _config;
+    private readonly _profile;
+    private readonly _aes;
+    private readonly _loading$;
+    private _requestCount;
+    constructor(_http: JoopHttpClient, _config: JoopConfigService, _profile: JoopClientProfile, _aes: JoopAesService);
+    /** Observable loading state — subscribe in any framework to drive a spinner. */
+    loading$(): JoopObservable<JoopLoadingState>;
+    isLoading(): boolean;
+    /**
+     * Send a service request to the configured base URL.
+     * @param serviceId  Service/endpoint identifier appended to the base URL
+     * @param data       Request payload
+     * @param options    Loader, error, method overrides
+     */
+    send<T = any>(serviceId: string, data?: Record<string, any>, options?: JoopRequestOptions): Promise<T>;
+    /** Upload a file with progress. */
+    upload<T = any>(serviceId: string, formData: FormData, onProgress: (pct: number) => void): Promise<T>;
+    private _buildUrl;
+    private _prepareBody;
+    private _handleResponse;
+    private _incrementLoader;
+    private _decrementLoader;
+}
+/** Convenience: catch JoopHttpError by status code. */
+declare function isHttpError(err: unknown, status?: number): err is JoopHttpError;
+
+interface JoopDownloadOptions {
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: string | FormData;
+    iosHandlerName?: string;
+}
+declare class JoopFileSaverService {
+    isIosWebView(handlerName?: string): boolean;
+    download(url: string, options?: JoopDownloadOptions): Promise<void>;
+    saveBlob(blob: Blob, fileName: string): void;
+    blobToBase64(blob: Blob): Promise<string>;
+    getMimeType(fileName: string): string;
+    typedBlob(blob: Blob, fileName: string): Blob;
+    private _sendToIos;
+    private _fileNameFromHeaders;
+}
+
+interface JoopRawComponent6 {
+    compKey: string;
+    compValue: string;
+}
+interface JoopRawResponse6 {
+    scrId?: string;
+    scrid?: string;
+    compDet?: JoopRawComponent6[];
+    segments?: string;
+    mxenc?: string;
+    mxencres?: string;
+    errorCode?: string;
+    errorDesc?: string;
+}
+interface JoopRawResponse {
+    scrid?: string;
+    segments?: string;
+    mxenc?: string;
+    mxencres?: string;
+    components?: Record<string, string>;
+    errorCode?: string;
+    errorDesc?: string;
+}
+interface JoopMappedComponent {
+    key: string;
+    value: string;
+    scope: string;
+    dataKey: string;
+}
+interface JoopMappedResponse {
+    scrid: string;
+    segments: string;
+    mxenc: string;
+    mxencres: string;
+    components: Record<string, string>;
+    componentList: JoopMappedComponent[];
+    errorCode?: string;
+    errorDesc?: string;
+    hasError: boolean;
+}
+declare class JoopResponseMapper {
+    /** Normalize a v6 or v7+ raw API response into a typed mapped response */
+    map(raw: JoopRawResponse | JoopRawResponse6): JoopMappedResponse;
+    /** Extract scope prefix from a component key (first char: M/O/N/S) */
+    extractScope(key: string): string;
+    /** Extract data key portion (everything after the first character) */
+    extractDataKey(key: string): string;
+    /**
+     * Build a property map from component list — groups by scope prefix.
+     * e.g. "MUserName" → { scope: 'M', dataKey: 'UserName', value: '...' }
+     */
+    buildScopedMap(response: JoopMappedResponse): Record<string, Record<string, string>>;
+    /** Get a single component value from a mapped response */
+    getComponent(response: JoopMappedResponse, key: string): string | null;
+    /** Check if the raw payload looks like a v7+ response (has 'components' key) */
+    private _isV7;
+    private _convertV6ToV7;
+}
+
+interface JoopCsvOptions {
+    delimiter?: string;
+    headers?: string[];
+    includeHeaders?: boolean;
+    bom?: boolean;
+    nullValue?: string;
+}
+declare class JoopExportService {
+    /** Convert an array of objects to a CSV string */
+    toCsv(data: Record<string, unknown>[], options?: JoopCsvOptions): string;
+    /** Trigger browser download of a CSV string */
+    downloadCsv(data: Record<string, unknown>[], filename: string, options?: JoopCsvOptions): void;
+    /** Download Excel-compatible CSV (with BOM so Excel reads UTF-8 correctly) */
+    downloadExcel(data: Record<string, unknown>[], filename: string, options?: JoopCsvOptions): void;
+    /** Convert data to a JSON string and download */
+    downloadJson(data: unknown, filename: string, indent?: number): void;
+    /** Download a plain-text file */
+    downloadText(content: string, filename: string): void;
+    /** Convert a 2D array (table) to CSV */
+    tableToCsv(rows: unknown[][], headers?: string[], delimiter?: string): string;
+    private _download;
+}
+
+type JoopWebhookProvider = 'stripe' | 'github' | 'generic';
+interface JoopWebhookOptions {
+    toleranceSeconds?: number;
+    algorithm?: 'SHA-256' | 'SHA-1' | 'SHA-512';
+}
+declare class JoopWebhookVerifier {
+    private _provider;
+    for(provider: JoopWebhookProvider): JoopWebhookVerifier;
+    verify(payload: string, signature: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** Stripe: `Stripe-Signature: t=...,v1=...` */
+    verifyStripe(payload: string, header: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** GitHub: `X-Hub-Signature-256: sha256=...` */
+    verifyGitHub(payload: string, header: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** Generic HMAC verification. signature is a hex string. */
+    verifyGeneric(payload: string, signature: string, secret: string, opts?: JoopWebhookOptions): Promise<boolean>;
+    /** Returns true if the timestamp is within tolerance of now */
+    verifyTimestamp(timestamp: number, toleranceSeconds?: number): boolean;
+    /** Compute the expected HMAC for a payload (for testing) */
+    sign(payload: string, secret: string, algo?: AlgorithmIdentifier): Promise<string>;
+}
+
+interface JoopIdempotencyConfig {
+    storage?: JoopStorageAdapter;
+    ttlMs?: number;
+    prefix?: string;
+}
+declare class JoopIdempotencyService {
+    private _storage;
+    private _ttlMs;
+    private _prefix;
+    /** Internal key registry used for clearAll() and gc() (avoids requiring Storage.length/key()) */
+    private _keys;
+    constructor(config?: JoopIdempotencyConfig);
+    /**
+     * Generate and store an idempotency key for the given operation.
+     * Returns an existing (non-expired) key if one already exists.
+     */
+    generate(operationKey: string): string;
+    /** Get the stored key for an operation, or null if expired/not found */
+    get(operationKey: string): string | null;
+    /** Remove the key for an operation (e.g. after successful completion) */
+    clear(operationKey: string): void;
+    /** Clear all idempotency keys managed by this instance */
+    clearAll(): void;
+    /**
+     * Wrap a fetch-based function with automatic idempotency key injection.
+     * Clears the key on success; keeps it on failure so retries reuse the same key.
+     */
+    wrap<T>(operationKey: string, fn: (idempotencyKey: string) => Promise<T>): Promise<T>;
+    /** Remove all expired entries */
+    gc(): void;
+}
+
+export { type JoopLoadingState as A, type JoopMappedComponent as B, type JoopMappedResponse as C, type JoopPollConfig as D, type JoopRawResponse as E, type JoopRawResponse6 as F, type JoopRequest as G, type JoopRequestInterceptor as H, type JoopResponse as I, JoopHttpClient as J, type JoopResponseInterceptor as K, type JoopWebhookOptions as L, type JoopWebhookProvider as M, isHttpError as N, type JoopRawComponent6 as O, JoopInterceptorPipeline as a, JoopCircuitBreaker as b, JoopOfflineQueue as c, JoopPollingService as d, JoopRequestService as e, JoopFileSaverService as f, JoopResponseMapper as g, JoopExportService as h, JoopWebhookVerifier as i, JoopIdempotencyService as j, type JoopCircuitBreakerConfig as k, JoopCircuitBreakerOpenError as l, JoopCircuitBreakerRegistry as m, type JoopCircuitBreakerState as n, type JoopCircuitBreakerStats as o, type JoopCircuitState as p, type JoopCsvOptions as q, type JoopDownloadOptions as r, JoopEncryptionError as s, type JoopError as t, type JoopErrorButton as u, type JoopErrorInterceptor as v, type JoopErrorType as w, type JoopFetchOptions as x, JoopHttpError as y, type JoopIdempotencyConfig as z };

package/dist/index-B_ksKpS1.d.mts

@@ -0,0 +1,202 @@
+import './config.service-Cz4QQLlf.mjs';
+import { e as JoopLoggerConfig } from './config.models-Cqg04fAQ.mjs';
+import { J as JoopObservable } from './index-Dz0gOur2.mjs';
+
+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-CqDKWTUP.d.mts

@@ -0,0 +1,28 @@
+declare enum JoopScopeType {
+    /** Application scope — lives for the lifetime of the app */
+    App = "app",
+    /** Page/flow scope — cleared on page navigation */
+    Page = "page",
+    /** Screen scope — cleared on screen change */
+    Screen = "screen",
+    /** Session scope — maps to sessionStorage semantics */
+    Session = "session"
+}
+declare enum JoopHttpMethod {
+    Get = "GET",
+    Post = "POST",
+    Put = "PUT",
+    Patch = "PATCH",
+    Delete = "DELETE"
+}
+declare enum JoopLogLevel {
+    Debug = "debug",
+    Log = "log",
+    Info = "info",
+    Warn = "warn",
+    Error = "error",
+    All = "all",
+    Off = "off"
+}
+
+export { JoopScopeType as J, JoopHttpMethod as a, JoopLogLevel as b };

package/dist/index-CqDKWTUP.d.ts

@@ -0,0 +1,28 @@
+declare enum JoopScopeType {
+    /** Application scope — lives for the lifetime of the app */
+    App = "app",
+    /** Page/flow scope — cleared on page navigation */
+    Page = "page",
+    /** Screen scope — cleared on screen change */
+    Screen = "screen",
+    /** Session scope — maps to sessionStorage semantics */
+    Session = "session"
+}
+declare enum JoopHttpMethod {
+    Get = "GET",
+    Post = "POST",
+    Put = "PUT",
+    Patch = "PATCH",
+    Delete = "DELETE"
+}
+declare enum JoopLogLevel {
+    Debug = "debug",
+    Log = "log",
+    Info = "info",
+    Warn = "warn",
+    Error = "error",
+    All = "all",
+    Off = "off"
+}
+
+export { JoopScopeType as J, JoopHttpMethod as a, JoopLogLevel as b };