joopjs 2.0.0

package/dist/vue/index.mjs

@@ -0,0 +1,619 @@
+// 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/platform/platform.ts
+var _webStorage = (store) => ({
+  getItem: (k) => store.getItem(k),
+  setItem: (k, v) => store.setItem(k, v),
+  removeItem: (k) => store.removeItem(k),
+  clear: () => store.clear()
+});
+var _MemStorageImpl = class {
+  _m = /* @__PURE__ */ new Map();
+  getItem(k) {
+    return this._m.get(k) ?? null;
+  }
+  setItem(k, v) {
+    this._m.set(k, v);
+  }
+  removeItem(k) {
+    this._m.delete(k);
+  }
+  clear() {
+    this._m.clear();
+  }
+};
+function _detect() {
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") return "react-native";
+  const _proc = globalThis["process"];
+  if (typeof window === "undefined" && _proc?.versions?.node) return "node";
+  if (typeof window !== "undefined") return "web";
+  return "unknown";
+}
+var JoopPlatform = class {
+  static _type = _detect();
+  static _adapter = {};
+  static _memStorage = null;
+  /**
+   * Call once at app startup to configure adapters for your platform.
+   *
+   * Web (default — no call needed):
+   *   JoopPlatform.init();
+   *
+   * React Native with react-native-mmkv:
+   *   import { MMKV } from 'react-native-mmkv';
+   *   const mmkv = new MMKV();
+   *   JoopPlatform.init({ adapter: { storage: mmkv } });
+   *
+   * React Native with custom compression (fflate):
+   *   import { gzip, ungzip } from 'fflate';
+   *   JoopPlatform.init({
+   *     adapter: {
+   *       compression: {
+   *         compress: (d, fmt) => new Promise((res, rej) => gzip(d, (e, r) => e ? rej(e) : res(r))),
+   *         decompress: (d, fmt) => new Promise((res, rej) => ungzip(d, (e, r) => e ? rej(e) : res(r))),
+   *       },
+   *     },
+   *   });
+   */
+  static init(config = {}) {
+    if (config.platform) this._type = config.platform;
+    this._adapter = { ...this._adapter, ...config.adapter ?? {} };
+  }
+  /** Current detected or overridden platform type */
+  static get type() {
+    return this._type;
+  }
+  static is(type) {
+    return this._type === type;
+  }
+  static isMobile() {
+    return this._type === "react-native";
+  }
+  static isWeb() {
+    return this._type === "web";
+  }
+  static isNode() {
+    return this._type === "node";
+  }
+  /** Raw adapter config registered via init() */
+  static getAdapter() {
+    return this._adapter;
+  }
+  /**
+   * Returns the best available storage adapter:
+   *   1. Custom adapter registered via init()
+   *   2. localStorage (web)
+   *   3. In-memory fallback (Node / RN without adapter)
+   */
+  static getStorage() {
+    if (this._adapter.storage) return this._adapter.storage;
+    if (typeof localStorage !== "undefined") return _webStorage(localStorage);
+    if (!this._memStorage) this._memStorage = new _MemStorageImpl();
+    return this._memStorage;
+  }
+  /**
+   * Returns the best available session-scoped storage:
+   *   1. Custom adapter registered via init()
+   *   2. sessionStorage (web)
+   *   3. Shared in-memory fallback
+   */
+  static getSessionStorage() {
+    if (this._adapter.storage) return this._adapter.storage;
+    if (typeof sessionStorage !== "undefined") return _webStorage(sessionStorage);
+    if (!this._memStorage) this._memStorage = new _MemStorageImpl();
+    return this._memStorage;
+  }
+  /** What APIs are available in the current environment */
+  static capabilities() {
+    return {
+      compression: typeof CompressionStream !== "undefined" || !!this._adapter.compression,
+      workers: typeof Worker !== "undefined" || !!this._adapter.worker,
+      cryptoSubtle: !!(typeof globalThis !== "undefined" && globalThis.crypto?.subtle),
+      persistentStorage: typeof localStorage !== "undefined" || !!this._adapter.storage,
+      dom: typeof document !== "undefined",
+      serviceWorker: typeof navigator !== "undefined" && "serviceWorker" in navigator
+    };
+  }
+  /** Reset to auto-detected defaults — useful between tests */
+  static _reset() {
+    this._type = _detect();
+    this._adapter = {};
+    this._memStorage = null;
+  }
+};
+
+// src/device/network-monitor.ts
+var JoopNetworkMonitor = class {
+  _adapter;
+  _state$;
+  _cleanup = [];
+  constructor(config = {}) {
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().network ?? null;
+    this._state$ = new JoopBehaviorSubject(this._read());
+    this._init();
+  }
+  _init() {
+    if (this._adapter) {
+      this._state$.next(this._adapter.getState());
+      const unsub = this._adapter.onChange((s) => this._state$.next(s));
+      this._cleanup.push(unsub);
+      return;
+    }
+    if (typeof window === "undefined") return;
+    const refresh = () => this._state$.next(this._read());
+    window.addEventListener("online", refresh);
+    window.addEventListener("offline", refresh);
+    const conn = navigator.connection;
+    if (conn) {
+      conn.addEventListener("change", refresh);
+      this._cleanup.push(() => conn.removeEventListener("change", refresh));
+    }
+    this._cleanup.push(
+      () => window.removeEventListener("online", refresh),
+      () => window.removeEventListener("offline", refresh)
+    );
+  }
+  _read() {
+    if (this._adapter) return this._adapter.getState();
+    if (typeof navigator === "undefined") return { online: false, type: "unknown" };
+    const online = navigator.onLine;
+    if (!online) return { online: false, type: "offline" };
+    const conn = navigator.connection;
+    const type = conn ? _mapType(conn.type) : "unknown";
+    return {
+      online,
+      type,
+      effectiveType: conn?.effectiveType,
+      downlink: conn?.downlink,
+      rtt: conn?.rtt,
+      saveData: conn?.saveData,
+      metered: conn?.metered ?? type === "cellular"
+    };
+  }
+  getState() {
+    return this._state$.getValue();
+  }
+  state$() {
+    return this._state$.asObservable();
+  }
+  isOnline() {
+    return this.getState().online;
+  }
+  isMetered() {
+    return this.getState().metered ?? this.getState().type === "cellular";
+  }
+  /** Call fn when connectivity is regained. */
+  onOnline(fn) {
+    let prev = this.getState().online;
+    return this._state$.subscribe((s) => {
+      if (s.online && !prev) fn();
+      prev = s.online;
+    });
+  }
+  /** Call fn when connectivity is lost. */
+  onOffline(fn) {
+    let prev = this.getState().online;
+    return this._state$.subscribe((s) => {
+      if (!s.online && prev) fn();
+      prev = s.online;
+    });
+  }
+  /** Call fn when the connection type changes (e.g. wifi → cellular). */
+  onTypeChange(fn) {
+    let prev = this.getState().type;
+    return this._state$.subscribe((s) => {
+      if (s.type !== prev) {
+        fn(s.type);
+        prev = s.type;
+      }
+    });
+  }
+  destroy() {
+    for (const fn of this._cleanup) fn();
+    this._cleanup = [];
+  }
+};
+function _mapType(raw) {
+  if (!raw) return "unknown";
+  if (raw === "wifi" || raw === "wimax") return "wifi";
+  if (raw === "cellular" || raw === "2g" || raw === "3g" || raw === "4g" || raw === "5g") return "cellular";
+  if (raw === "ethernet") return "ethernet";
+  if (raw === "none" || raw === "offline") return "offline";
+  return "unknown";
+}
+
+// src/device/app-lifecycle.ts
+var JoopAppLifecycle = class {
+  _state$ = new JoopBehaviorSubject("unknown");
+  _cleanup = [];
+  _adapter;
+  constructor(config = {}) {
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().lifecycle ?? null;
+    this._init();
+  }
+  _init() {
+    if (this._adapter) {
+      this._state$.next(this._adapter.getState());
+      const unsub = this._adapter.onChange((s) => this._state$.next(s));
+      this._cleanup.push(unsub);
+      return;
+    }
+    if (typeof document === "undefined") {
+      this._state$.next("unknown");
+      return;
+    }
+    this._state$.next(document.hidden ? "background" : "active");
+    const onVisibility = () => this._state$.next(document.hidden ? "background" : "active");
+    const onFocus = () => this._state$.next("active");
+    const onBlur = () => this._state$.next("background");
+    document.addEventListener("visibilitychange", onVisibility);
+    window.addEventListener("focus", onFocus);
+    window.addEventListener("blur", onBlur);
+    this._cleanup.push(
+      () => document.removeEventListener("visibilitychange", onVisibility),
+      () => window.removeEventListener("focus", onFocus),
+      () => window.removeEventListener("blur", onBlur)
+    );
+  }
+  getState() {
+    return this._state$.getValue();
+  }
+  state$() {
+    return this._state$.asObservable();
+  }
+  isActive() {
+    return this.getState() === "active";
+  }
+  /** Call fn each time the app comes to the foreground (background → active). */
+  onForeground(fn) {
+    let prev = this.getState();
+    return this._state$.subscribe((s) => {
+      if (s === "active" && prev !== "active") fn();
+      prev = s;
+    });
+  }
+  /** Call fn each time the app goes to the background (active → background). */
+  onBackground(fn) {
+    let prev = this.getState();
+    return this._state$.subscribe((s) => {
+      if (s === "background" && prev !== "background") fn();
+      prev = s;
+    });
+  }
+  destroy() {
+    for (const fn of this._cleanup) fn();
+    this._cleanup = [];
+  }
+};
+
+// src/device/key-vault.ts
+var JoopKeyVault = class {
+  _prefix;
+  _encKey;
+  _adapter;
+  _cryptoKey = null;
+  constructor(config = {}) {
+    this._prefix = config.prefix ?? "joop_vault_";
+    this._encKey = config.encryptionKey;
+    this._adapter = config.adapter ?? JoopPlatform.getAdapter().keyVault ?? null;
+  }
+  /** Store a secret. On web: AES-GCM encrypted if `encryptionKey` was provided. */
+  async set(key, value) {
+    if (this._adapter) return this._adapter.set(key, value);
+    const stored = this._encKey ? await _encrypt(value, await this._key()) : btoa(unescape(encodeURIComponent(value)));
+    JoopPlatform.getStorage().setItem(this._prefix + key, stored);
+  }
+  /** Retrieve a secret, or null if not found. */
+  async get(key) {
+    if (this._adapter) return this._adapter.get(key);
+    const raw = JoopPlatform.getStorage().getItem(this._prefix + key);
+    if (!raw) return null;
+    try {
+      return this._encKey ? await _decrypt(raw, await this._key()) : decodeURIComponent(escape(atob(raw)));
+    } catch {
+      return null;
+    }
+  }
+  async remove(key) {
+    if (this._adapter) return this._adapter.remove(key);
+    JoopPlatform.getStorage().removeItem(this._prefix + key);
+  }
+  async clear() {
+    if (this._adapter) return this._adapter.clear();
+    JoopPlatform.getStorage().clear?.();
+  }
+  async has(key) {
+    return await this.get(key) !== null;
+  }
+  /** Rotate the encryption key: re-encrypts all known entries with a new key. */
+  async rotateKey(newEncryptionKey, keys) {
+    if (this._adapter) throw new Error("rotateKey not supported with native adapter");
+    const values = await Promise.all(keys.map((k) => this.get(k)));
+    this._encKey = newEncryptionKey;
+    this._cryptoKey = null;
+    for (let i = 0; i < keys.length; i++) {
+      if (values[i] !== null) await this.set(keys[i], values[i]);
+    }
+  }
+  async _key() {
+    if (!this._cryptoKey) this._cryptoKey = await _deriveKey(this._encKey);
+    return this._cryptoKey;
+  }
+};
+var _SALT = new Uint8Array([
+  106,
+  111,
+  111,
+  112,
+  45,
+  118,
+  97,
+  117,
+  108,
+  116,
+  45,
+  118,
+  49,
+  0,
+  0,
+  0
+]);
+async function _deriveKey(password) {
+  const km = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    { name: "PBKDF2" },
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt: _SALT, iterations: 1e5, hash: "SHA-256" },
+    km,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function _encrypt(value, key) {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encrypted = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    new TextEncoder().encode(value)
+  );
+  const combined = new Uint8Array(12 + encrypted.byteLength);
+  combined.set(iv);
+  combined.set(new Uint8Array(encrypted), 12);
+  return btoa(String.fromCharCode(...combined));
+}
+async function _decrypt(encoded, key) {
+  const combined = Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
+  const iv = combined.slice(0, 12);
+  const data = combined.slice(12);
+  const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, data);
+  return new TextDecoder().decode(decrypted);
+}
+
+// src/vue/index.ts
+function createJoopVue(vue) {
+  const { ref, computed, onUnmounted, provide, inject } = vue;
+  const JoopKey = /* @__PURE__ */ Symbol("JoopInstance");
+  function provideJoop(instance) {
+    provide(JoopKey, instance);
+  }
+  function useJoop() {
+    const joop = inject(JoopKey, null);
+    if (!joop) throw new Error("[joopjs] useJoop() must be called inside a component where provideJoop() was called");
+    return joop;
+  }
+  function useJoopNetworkMonitor() {
+    const monitor = new JoopNetworkMonitor();
+    const state = ref(monitor.getState());
+    const unsub = monitor.state$().subscribe((s) => {
+      state.value = { ...s };
+    });
+    onUnmounted(() => {
+      unsub();
+      monitor.destroy();
+    });
+    return {
+      online: computed(() => state.value.online),
+      type: computed(() => state.value.type),
+      effectiveType: computed(() => state.value.effectiveType),
+      isMetered: computed(() => state.value.metered ?? state.value.type === "cellular"),
+      monitor
+    };
+  }
+  function useJoopAppLifecycle() {
+    const lc = new JoopAppLifecycle();
+    const state = ref(lc.getState());
+    const unsub = lc.state$().subscribe((s) => {
+      state.value = s;
+    });
+    onUnmounted(() => {
+      unsub();
+      lc.destroy();
+    });
+    return {
+      state: computed(() => state.value),
+      isActive: computed(() => state.value === "active")
+    };
+  }
+  function useJoopKeyVault(key, vaultConfig) {
+    const vault = new JoopKeyVault(vaultConfig);
+    const value = ref(null);
+    const loading = ref(true);
+    const refresh = async () => {
+      loading.value = true;
+      value.value = await vault.get(key);
+      loading.value = false;
+    };
+    refresh();
+    return {
+      value,
+      loading,
+      async set(v) {
+        await vault.set(key, v);
+        value.value = v;
+      },
+      async remove() {
+        await vault.remove(key);
+        value.value = null;
+      },
+      refresh
+    };
+  }
+  function useJoopAuth() {
+    const joop = useJoop();
+    const isLoggedIn = ref(joop.auth.isLoggedIn());
+    const unsub = joop.auth.isLoggedIn$().subscribe((v) => {
+      isLoggedIn.value = v;
+    });
+    onUnmounted(() => unsub());
+    return {
+      isLoggedIn,
+      login: () => joop.auth.setLoggedIn(true),
+      logout: () => joop.auth.logout()
+    };
+  }
+  function useJoopTheme() {
+    const joop = useJoop();
+    const active = ref(joop.theme.getActiveName());
+    const themes = computed(() => joop.theme.getMapped());
+    const unsub = joop.theme.active$().subscribe((name) => {
+      active.value = name;
+    });
+    onUnmounted(() => unsub());
+    return {
+      active,
+      themes,
+      setTheme: (nameOrId) => joop.theme.apply(nameOrId)
+    };
+  }
+  function useJoopI18n() {
+    const joop = useJoop();
+    const details = joop.i18n.getDetails();
+    const language = ref(details.code);
+    const direction = ref(details.direction);
+    const unsub = joop.i18n.language$().subscribe((lang) => {
+      language.value = lang;
+      direction.value = joop.i18n.getDirection();
+    });
+    onUnmounted(() => unsub());
+    return {
+      language,
+      direction,
+      t: (key, params) => joop.i18n.t(key, params),
+      setLanguage: (lang) => joop.i18n.setLanguage(lang)
+    };
+  }
+  function useJoopLoader() {
+    const joop = useJoop();
+    const isLoading = ref(joop.loader.isLoading());
+    const unsub = joop.loader.isLoading$().subscribe((v) => {
+      isLoading.value = v;
+    });
+    onUnmounted(() => unsub());
+    return {
+      isLoading,
+      show: () => joop.loader.show(),
+      hide: () => joop.loader.hide()
+    };
+  }
+  function useJoopConfig(key) {
+    const joop = useJoop();
+    return computed(() => joop.config.get(key));
+  }
+  function useJoopFeatureFlag(flagKey, context) {
+    const joop = useJoop();
+    return {
+      enabled: computed(() => joop.featureFlags.isEnabled(flagKey, context)),
+      variant: computed(() => joop.featureFlags.getVariant(flagKey, context))
+    };
+  }
+  function useJoopStore(selector) {
+    const joop = useJoop();
+    const store = joop.store;
+    const value = ref(selector(store.getState()));
+    const unsub = store.subscribe((s) => {
+      value.value = selector(s);
+    });
+    onUnmounted(() => unsub());
+    return value;
+  }
+  return {
+    JoopKey,
+    provideJoop,
+    useJoop,
+    useJoopNetworkMonitor,
+    useJoopAppLifecycle,
+    useJoopKeyVault,
+    useJoopAuth,
+    useJoopTheme,
+    useJoopI18n,
+    useJoopLoader,
+    useJoopConfig,
+    useJoopFeatureFlag,
+    useJoopStore
+  };
+}
+
+export { createJoopVue };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map