joopjs 2.0.0

package/dist/core/index.mjs

@@ -0,0 +1,619 @@
+// src/constants/index.ts
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+
+// src/utilities/common.utility.ts
+function removeTrailingSlash(url) {
+  return url?.endsWith("/") ? url.slice(0, -1) : url;
+}
+
+// src/core/config/config.service.ts
+var JoopConfigService = class {
+  _config = null;
+  /**
+   * Load config from a remote URL (e.g. config/settings.json) or use an already-resolved object.
+   */
+  async load(configOrUrl) {
+    if (configOrUrl && typeof configOrUrl === "object") {
+      this._config = configOrUrl;
+      return this._config;
+    }
+    const url = typeof configOrUrl === "string" ? configOrUrl : "config/settings.json";
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to load config from ${url}: ${res.statusText}`);
+    this._config = await res.json();
+    return this._config;
+  }
+  /** Set config directly without fetching. */
+  setConfig(config) {
+    this._config = config;
+  }
+  /** Generic key access. */
+  get(key) {
+    return this._raw?.[key];
+  }
+  get app() {
+    return this._raw.app;
+  }
+  get timeout() {
+    return this._raw.timeout;
+  }
+  get requestTimeout() {
+    return this._raw.timeout?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+  }
+  get session() {
+    return this._raw.timeout?.session;
+  }
+  get localization() {
+    return this._raw.localization;
+  }
+  get loggerConfig() {
+    return this._raw.logger;
+  }
+  get isLoggerEnabled() {
+    return this._raw.logger?.enable ?? false;
+  }
+  get isLoggerDateEnabled() {
+    return this._raw.logger?.enableDate ?? false;
+  }
+  get loggerTypeConfig() {
+    return this._raw.logger?.typeConfig ?? {};
+  }
+  get logoutService() {
+    return this._raw.app?.logoutService ?? "";
+  }
+  get ignoreServices() {
+    return this._raw.timeout?.session?.ignoreServices ?? [];
+  }
+  get baseUrl() {
+    return removeTrailingSlash(this._raw.app?.baseUrl ?? "");
+  }
+  get isDevMode() {
+    return this._raw.isDevMode ?? false;
+  }
+  get _raw() {
+    if (!this._config) throw new Error("JoopConfigService: config not loaded. Call load() first.");
+    return this._config;
+  }
+};
+var configService = new JoopConfigService();
+
+// src/events/index.ts
+var JoopSubject = class {
+  _listeners = [];
+  subscribe(listener) {
+    this._listeners.push(listener);
+    return () => {
+      this._listeners = this._listeners.filter((l) => l !== listener);
+    };
+  }
+  next(value) {
+    for (const listener of this._listeners) {
+      listener(value);
+    }
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopBehaviorSubject = class extends JoopSubject {
+  _value;
+  constructor(initialValue) {
+    super();
+    this._value = initialValue;
+  }
+  getValue() {
+    return this._value;
+  }
+  next(value) {
+    this._value = value;
+    super.next(value);
+  }
+  subscribe(listener) {
+    listener(this._value);
+    return super.subscribe(listener);
+  }
+  asObservable() {
+    return new JoopObservable((listener) => this.subscribe(listener));
+  }
+};
+var JoopObservable = class {
+  constructor(_subscribeFn) {
+    this._subscribeFn = _subscribeFn;
+  }
+  _subscribeFn;
+  subscribe(listener) {
+    return this._subscribeFn(listener);
+  }
+  /** Returns the current value without subscribing (only meaningful for BehaviorSubject-backed observables). */
+  getOnce() {
+    let result;
+    const unsub = this.subscribe((v) => {
+      result = v;
+    });
+    unsub();
+    return result;
+  }
+};
+
+// src/core/logger/logger.service.ts
+var JoopLogger = class {
+  _logSubject = new JoopSubject();
+  _config = { enable: false };
+  configure(config) {
+    this._config = config;
+  }
+  debug(message, options) {
+    this._emit("debug", message, options);
+  }
+  log(message, options) {
+    this._emit("log", message, options);
+  }
+  info(message, options) {
+    this._emit("info", message, options);
+  }
+  warn(message, options) {
+    this._emit("warn", message, options);
+  }
+  error(message, options) {
+    this._emit("error", message, options);
+  }
+  /** Subscribe to all log entries (useful for remote logging). */
+  onLog(listener) {
+    return this._logSubject.subscribe(listener);
+  }
+  _shouldLog(level) {
+    if (!this._config.enable) return false;
+    const tc = this._config.typeConfig ?? {};
+    return !!(tc["all"] || tc[level]);
+  }
+  _emit(level, message, options) {
+    if (!this._shouldLog(level)) return;
+    const timestamp = this._config.enableDate || options?.isDateEnabled ? (/* @__PURE__ */ new Date()).toISOString() : void 0;
+    const entry = { level, message, timestamp, component: options?.componentName };
+    this._logSubject.next(entry);
+    const prefix = [timestamp, options?.componentName].filter(Boolean).join(" ");
+    const style = options?.color ? `color: ${options.color}` : "";
+    const text = prefix ? `${prefix} ${this._serialize(message)}` : this._serialize(message);
+    switch (level) {
+      case "debug":
+        return void console.debug(`%c${text}`, style);
+      case "log":
+        return void console.log(`%c${text}`, style);
+      case "info":
+        return void console.info(`%c${text}`, style);
+      case "warn":
+        return void console.warn(`%c${text}`, style);
+      case "error":
+        return void console.error(`%c${text}`, style);
+    }
+  }
+  _serialize(message) {
+    if (typeof message === "string") return message;
+    try {
+      return JSON.stringify(message);
+    } catch {
+      return String(message);
+    }
+  }
+};
+var logger = new JoopLogger();
+
+// src/core/plugin.service.ts
+var JoopPluginService = class {
+  _plugins = /* @__PURE__ */ new Map();
+  _context = {};
+  setContext(ctx) {
+    this._context = { ...this._context, ...ctx };
+  }
+  async use(plugin) {
+    if (this._plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    await plugin.install(this._context);
+    this._plugins.set(plugin.name, plugin);
+  }
+  unuse(name) {
+    const plugin = this._plugins.get(name);
+    if (!plugin) return;
+    plugin.uninstall?.();
+    this._plugins.delete(name);
+  }
+  has(name) {
+    return this._plugins.has(name);
+  }
+  getAll() {
+    return [...this._plugins.values()];
+  }
+  unuseAll() {
+    [...this._plugins.keys()].forEach((n) => this.unuse(n));
+  }
+};
+
+// src/core/environment.service.ts
+var JoopEnvironmentService = class {
+  _current = null;
+  _profiles = /* @__PURE__ */ new Map();
+  register(profile) {
+    this._profiles.set(profile.name, profile);
+  }
+  activate(name) {
+    const profile = this._profiles.get(name);
+    if (!profile) throw new Error(`Environment profile "${name}" not registered`);
+    this._current = profile;
+  }
+  detect() {
+    const nodeEnv = typeof globalThis !== "undefined" && globalThis.process?.env?.NODE_ENV;
+    if (nodeEnv) return nodeEnv;
+    if (typeof window !== "undefined") {
+      const host = window.location.hostname;
+      if (host === "localhost" || host === "127.0.0.1") return "development";
+      if (host.includes("staging") || host.includes("uat") || host.includes("test")) return "staging";
+    }
+    return "production";
+  }
+  get current() {
+    if (!this._current) throw new Error("No environment activated \u2014 call activate() first");
+    return this._current;
+  }
+  get name() {
+    return this.current.name;
+  }
+  get apiBaseUrl() {
+    return this.current.apiBaseUrl;
+  }
+  isDev() {
+    return this.current.name === "development";
+  }
+  isStaging() {
+    return this.current.name === "staging";
+  }
+  isProduction() {
+    return this.current.name === "production";
+  }
+  isFeatureEnabled(feature) {
+    return this.current.features?.[feature] ?? false;
+  }
+  get(key) {
+    return this.current[key];
+  }
+};
+
+// src/core/health.service.ts
+var JoopHealthService = class {
+  _checks = [];
+  register(check) {
+    this._checks.push(check);
+  }
+  async runAll() {
+    return Promise.all(this._checks.map((c) => this._run(c)));
+  }
+  async run(name) {
+    const check = this._checks.find((c) => c.name === name);
+    return check ? this._run(check) : null;
+  }
+  async pingUrl(url, timeoutMs = 5e3) {
+    const start = performance.now();
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      const res = await fetch(url, { method: "HEAD", signal: controller.signal });
+      clearTimeout(timer);
+      return { name: url, healthy: res.ok, latencyMs: Math.round(performance.now() - start), timestamp: Date.now() };
+    } catch (err) {
+      return {
+        name: url,
+        healthy: false,
+        latencyMs: Math.round(performance.now() - start),
+        error: err instanceof Error ? err.message : String(err),
+        timestamp: Date.now()
+      };
+    }
+  }
+  async _run(check) {
+    const start = performance.now();
+    try {
+      const result = await Promise.race([
+        check.check(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), check.timeoutMs ?? 5e3)
+        )
+      ]);
+      return { name: check.name, healthy: result, latencyMs: Math.round(performance.now() - start), timestamp: Date.now() };
+    } catch (err) {
+      return {
+        name: check.name,
+        healthy: false,
+        latencyMs: Math.round(performance.now() - start),
+        error: err instanceof Error ? err.message : String(err),
+        timestamp: Date.now()
+      };
+    }
+  }
+};
+
+// src/core/feature-flag.service.ts
+var JoopFeatureFlagService = class {
+  _flags = /* @__PURE__ */ new Map();
+  _overrides = /* @__PURE__ */ new Map();
+  _context = {};
+  _flags$ = new JoopBehaviorSubject(/* @__PURE__ */ new Map());
+  /** Register flag definitions */
+  define(flags) {
+    for (const f of flags) this._flags.set(f.key, f);
+    this._flags$.next(new Map(this._flags));
+  }
+  /** Load flags from a remote JSON endpoint */
+  async loadFromUrl(url) {
+    const res = await fetch(url);
+    const flags = await res.json();
+    this.define(flags);
+  }
+  /** Set user/environment context for targeting */
+  setContext(ctx) {
+    this._context = { ...this._context, ...ctx };
+  }
+  /** Check if a feature flag is enabled for the current context */
+  isEnabled(key, context) {
+    if (this._overrides.has(key)) return this._overrides.get(key);
+    const flag = this._flags.get(key);
+    if (!flag) return false;
+    if (!flag.enabled) return false;
+    const ctx = { ...this._context, ...context };
+    if (flag.environments?.length && ctx.environment && !flag.environments.includes(ctx.environment)) return false;
+    if (flag.allowedUsers?.length && ctx.userId && !flag.allowedUsers.includes(ctx.userId)) return false;
+    if (flag.rolloutPercent !== void 0 && ctx.userId) {
+      const hash = this._hash(`${key}:${ctx.userId}`);
+      if (hash % 100 >= flag.rolloutPercent) return false;
+    }
+    return true;
+  }
+  /** Get the variant string for a flag */
+  getVariant(key, context) {
+    if (!this.isEnabled(key, context)) return null;
+    return this._flags.get(key)?.variant ?? null;
+  }
+  /** Override a flag locally (for testing) */
+  setOverride(key, value) {
+    this._overrides.set(key, value);
+    this._flags$.next(new Map(this._flags));
+  }
+  clearOverrides() {
+    this._overrides.clear();
+    this._flags$.next(new Map(this._flags));
+  }
+  getAllFlags() {
+    return [...this._flags.values()];
+  }
+  getFlag(key) {
+    return this._flags.get(key);
+  }
+  flags$() {
+    return this._flags$.asObservable();
+  }
+  /** Simple deterministic hash for percentage rollouts */
+  _hash(str) {
+    let h = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+      h ^= str.charCodeAt(i);
+      h = h * 16777619 >>> 0;
+    }
+    return h;
+  }
+};
+
+// src/core/rate-limiter.service.ts
+var JoopTokenBucket = class {
+  _tokens;
+  _lastRefill;
+  _cap;
+  _rate;
+  constructor(config) {
+    this._cap = config.capacity;
+    this._rate = config.refillRate;
+    this._tokens = config.capacity;
+    this._lastRefill = Date.now();
+  }
+  _refill() {
+    const now = Date.now();
+    const elapsed = (now - this._lastRefill) / 1e3;
+    this._tokens = Math.min(this._cap, this._tokens + elapsed * this._rate);
+    this._lastRefill = now;
+  }
+  /** Returns true if tokens were available and consumed */
+  consume(tokens = 1) {
+    this._refill();
+    if (this._tokens < tokens) return false;
+    this._tokens -= tokens;
+    return true;
+  }
+  /** Waits until enough tokens are available, then consumes */
+  tryConsume(tokens = 1) {
+    return new Promise((resolve) => {
+      const attempt = () => {
+        if (this.consume(tokens)) {
+          resolve();
+          return;
+        }
+        const wait = Math.ceil((tokens - this._tokens) / this._rate * 1e3);
+        setTimeout(attempt, wait);
+      };
+      attempt();
+    });
+  }
+  available() {
+    this._refill();
+    return Math.floor(this._tokens);
+  }
+  reset() {
+    this._tokens = this._cap;
+    this._lastRefill = Date.now();
+  }
+};
+var JoopRateLimiter = class {
+  _buckets = /* @__PURE__ */ new Map();
+  _timers = /* @__PURE__ */ new Map();
+  /** Create or get a token bucket by key */
+  bucket(key, config) {
+    if (!this._buckets.has(key)) {
+      this._buckets.set(key, new JoopTokenBucket(config ?? { capacity: 10, refillRate: 1 }));
+    }
+    return this._buckets.get(key);
+  }
+  deleteBucket(key) {
+    this._buckets.delete(key);
+  }
+  /** Returns a throttled version — at most once per delayMs */
+  throttle(fn, delayMs) {
+    let lastCall = 0;
+    return (...args) => {
+      const now = Date.now();
+      if (now - lastCall >= delayMs) {
+        lastCall = now;
+        fn(...args);
+      }
+    };
+  }
+  /** Returns a debounced version — fires after delayMs of silence */
+  debounce(fn, delayMs, immediate = false) {
+    let timer = null;
+    return (...args) => {
+      if (timer) clearTimeout(timer);
+      if (immediate && !timer) fn(...args);
+      timer = setTimeout(() => {
+        timer = null;
+        if (!immediate) fn(...args);
+      }, delayMs);
+    };
+  }
+  /** Promise-based debounce — resolves when the debounced call fires */
+  debounceAsync(fn, delayMs) {
+    let timer = null;
+    let resolve = null;
+    let reject = null;
+    let pending = null;
+    return () => {
+      if (!pending) pending = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(async () => {
+        timer = null;
+        pending = null;
+        try {
+          const v = await fn();
+          resolve?.(v);
+        } catch (e) {
+          reject?.(e);
+        }
+        resolve = null;
+        reject = null;
+      }, delayMs);
+      return pending;
+    };
+  }
+  /** Ensure a function is called at most once per key in the given window */
+  once(key, fn, windowMs) {
+    if (this._timers.has(key)) return false;
+    fn();
+    this._timers.set(key, setTimeout(() => this._timers.delete(key), windowMs));
+    return true;
+  }
+};
+
+// src/core/consent.service.ts
+var STORAGE_KEY = "joop_consent";
+var ALL = ["necessary", "analytics", "marketing", "functional", "personalization"];
+var DEFAULT_STATE = {
+  decided: false,
+  categories: { necessary: true, analytics: false, marketing: false, functional: false, personalization: false },
+  timestamp: null
+};
+var JoopConsentService = class {
+  _state$;
+  constructor(storageKey = STORAGE_KEY) {
+    this._state$ = new JoopBehaviorSubject(this._loadFrom(storageKey));
+    this._key = storageKey;
+  }
+  _key;
+  _loadFrom(key) {
+    try {
+      const raw = localStorage.getItem(key);
+      if (raw) return { ...DEFAULT_STATE, ...JSON.parse(raw) };
+    } catch {
+    }
+    return { ...DEFAULT_STATE, categories: { ...DEFAULT_STATE.categories } };
+  }
+  /** Grant one or more categories */
+  grant(categories) {
+    const cats = Array.isArray(categories) ? categories : [categories];
+    const s = this._state$.getValue();
+    const next = { ...s, decided: true, timestamp: Date.now(), categories: { ...s.categories } };
+    for (const c of cats) next.categories[c] = true;
+    this._state$.next(next);
+    this._persist(next);
+  }
+  /** Revoke one or more categories (cannot revoke 'necessary') */
+  revoke(categories) {
+    const cats = (Array.isArray(categories) ? categories : [categories]).filter((c) => c !== "necessary");
+    const s = this._state$.getValue();
+    const next = { ...s, decided: true, timestamp: Date.now(), categories: { ...s.categories } };
+    for (const c of cats) next.categories[c] = false;
+    this._state$.next(next);
+    this._persist(next);
+  }
+  /** Grant all categories at once */
+  acceptAll() {
+    this.grant(ALL);
+  }
+  /** Reject all non-necessary categories */
+  rejectAll() {
+    this.revoke(ALL.filter((c) => c !== "necessary"));
+  }
+  isGranted(category) {
+    return this._state$.getValue().categories[category] ?? false;
+  }
+  hasDecided() {
+    return this._state$.getValue().decided;
+  }
+  getAll() {
+    return { ...this._state$.getValue().categories };
+  }
+  getState() {
+    return this._state$.getValue();
+  }
+  state$() {
+    return this._state$.asObservable();
+  }
+  reset() {
+    const fresh = { ...DEFAULT_STATE, categories: { ...DEFAULT_STATE.categories } };
+    this._state$.next(fresh);
+    try {
+      localStorage.removeItem(this._key);
+    } catch {
+    }
+  }
+  onChange(handler) {
+    return this._state$.subscribe(handler);
+  }
+  onCategoryChange(category, handler) {
+    let prev = this.isGranted(category);
+    return this._state$.subscribe((s) => {
+      const cur = s.categories[category] ?? false;
+      if (cur !== prev) {
+        prev = cur;
+        handler(cur);
+      }
+    });
+  }
+  _persist(state) {
+    try {
+      localStorage.setItem(this._key, JSON.stringify(state));
+    } catch {
+    }
+  }
+};
+
+export { JoopConfigService, JoopConsentService, JoopEnvironmentService, JoopFeatureFlagService, JoopHealthService, JoopLogger, JoopPluginService, JoopRateLimiter, JoopTokenBucket, configService, logger };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map