joopjs 2.0.0

package/dist/react/index.mjs

@@ -0,0 +1,630 @@
+// 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/react/index.ts
+function createJoopReact(react) {
+  const {
+    useState,
+    useEffect,
+    useCallback,
+    useMemo,
+    useRef,
+    createContext,
+    useContext,
+    createElement
+  } = react;
+  const JoopCtx = createContext(null);
+  function JoopProvider(props) {
+    return createElement(
+      JoopCtx.Provider,
+      { value: props.joop },
+      props.children
+    );
+  }
+  function useJoop() {
+    const joop = useContext(JoopCtx);
+    if (!joop) throw new Error("[joopjs] useJoop must be called inside <JoopProvider>");
+    return joop;
+  }
+  function useJoopNetworkMonitor() {
+    const ref = useRef();
+    if (!ref.current) ref.current = new JoopNetworkMonitor();
+    const monitor = ref.current;
+    const [state, setState] = useState(() => monitor.getState());
+    useEffect(() => {
+      const unsub = monitor.state$().subscribe((s) => setState({ ...s }));
+      return () => {
+        unsub();
+        monitor.destroy();
+      };
+    }, []);
+    return { ...state, monitor };
+  }
+  function useJoopAppLifecycle() {
+    const ref = useRef();
+    if (!ref.current) ref.current = new JoopAppLifecycle();
+    const lc = ref.current;
+    const [state, setState] = useState(() => lc.getState());
+    useEffect(() => {
+      const unsub = lc.state$().subscribe((s) => setState(s));
+      return () => {
+        unsub();
+        lc.destroy();
+      };
+    }, []);
+    return { state, isActive: state === "active" };
+  }
+  function useJoopKeyVault(key, vaultConfig) {
+    const vaultRef = useRef();
+    if (!vaultRef.current) vaultRef.current = new JoopKeyVault(vaultConfig);
+    const vault = vaultRef.current;
+    const [value, setValue] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const refresh = useCallback(async () => {
+      setLoading(true);
+      setValue(await vault.get(key));
+      setLoading(false);
+    }, [key]);
+    useEffect(() => {
+      refresh();
+    }, [key]);
+    const set = useCallback(async (v) => {
+      await vault.set(key, v);
+      setValue(v);
+    }, [key]);
+    const remove = useCallback(async () => {
+      await vault.remove(key);
+      setValue(null);
+    }, [key]);
+    return { value, loading, set, remove, refresh };
+  }
+  function useJoopAuth() {
+    const joop = useJoop();
+    const [isLoggedIn, setLoggedIn] = useState(() => joop.auth.isLoggedIn());
+    useEffect(() => {
+      const unsub = joop.auth.isLoggedIn$().subscribe((v) => setLoggedIn(v));
+      return () => unsub();
+    }, []);
+    const login = useCallback(() => joop.auth.setLoggedIn(true), []);
+    const logout = useCallback(() => joop.auth.logout(), []);
+    return { isLoggedIn, user: null, login, logout };
+  }
+  function useJoopTheme() {
+    const joop = useJoop();
+    const [active, setActive] = useState(() => joop.theme.getActiveName());
+    const themes = useMemo(() => joop.theme.getMapped(), []);
+    useEffect(() => {
+      const unsub = joop.theme.active$().subscribe((name) => setActive(name));
+      return () => unsub();
+    }, []);
+    const setTheme = useCallback((nameOrId) => {
+      joop.theme.apply(nameOrId);
+    }, []);
+    return { active, themes, setTheme };
+  }
+  function useJoopI18n() {
+    const joop = useJoop();
+    const [language, setLang] = useState(() => joop.i18n.getDetails().code);
+    const [direction, setDir] = useState(() => joop.i18n.getDirection());
+    useEffect(() => {
+      const unsub = joop.i18n.language$().subscribe((lang) => {
+        setLang(lang);
+        setDir(joop.i18n.getDirection());
+      });
+      return () => unsub();
+    }, []);
+    const t = useCallback(
+      (key, params) => joop.i18n.t(key, params),
+      [language]
+    );
+    const setLanguage = useCallback((lang) => joop.i18n.setLanguage(lang), []);
+    return { language, direction, t, setLanguage };
+  }
+  function useJoopLoader() {
+    const joop = useJoop();
+    const [isLoading, setLoading] = useState(() => joop.loader.isLoading());
+    useEffect(() => {
+      const unsub = joop.loader.isLoading$().subscribe((v) => setLoading(v));
+      return () => unsub();
+    }, []);
+    const show = useCallback(() => joop.loader.show(), []);
+    const hide = useCallback(() => joop.loader.hide(), []);
+    return { isLoading, show, hide };
+  }
+  function useJoopConfig(key) {
+    const joop = useJoop();
+    return useMemo(() => joop.config.get(key), [key]);
+  }
+  function useJoopFeatureFlag(flagKey, context) {
+    const joop = useJoop();
+    const enabled = useMemo(
+      () => joop.featureFlags.isEnabled(flagKey, context),
+      [flagKey]
+    );
+    const variant = useMemo(
+      () => joop.featureFlags.getVariant(flagKey, context),
+      [flagKey]
+    );
+    return { enabled, variant };
+  }
+  function useJoopStore(selector) {
+    const joop = useJoop();
+    const store = joop.store;
+    const [value, setValue] = useState(() => selector(store.getState()));
+    useEffect(() => {
+      const unsub = store.subscribe((s) => {
+        setValue(selector(s));
+      });
+      return () => unsub();
+    }, []);
+    return value;
+  }
+  return {
+    JoopProvider,
+    JoopCtx,
+    useJoop,
+    useJoopNetworkMonitor,
+    useJoopAppLifecycle,
+    useJoopKeyVault,
+    useJoopAuth,
+    useJoopTheme,
+    useJoopI18n,
+    useJoopLoader,
+    useJoopConfig,
+    useJoopFeatureFlag,
+    useJoopStore
+  };
+}
+
+export { createJoopReact };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map