@lunora/react 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/useAuth-CNUKtOOp.mjs

@@ -0,0 +1,129 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useSyncExternalStore } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+
+const stores = /* @__PURE__ */ new WeakMap();
+const createStore = (client) => {
+  const listeners = /* @__PURE__ */ new Set();
+  let user = null;
+  const notify = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  let generation = 0;
+  const setUser = (next) => {
+    if (user !== next) {
+      user = next;
+      notify();
+    }
+  };
+  const refresh = () => {
+    generation += 1;
+    const current = generation;
+    if (client.getAuthToken() === null) {
+      setUser(null);
+      return;
+    }
+    client.getCurrentUser().then((next) => {
+      if (current === generation) {
+        setUser(next);
+      }
+      return void 0;
+    }).catch(() => {
+      if (current === generation) {
+        setUser(null);
+      }
+    });
+  };
+  let unsubscribeToken;
+  return {
+    getSnapshot: () => user,
+    subscribe: (onChange) => {
+      const firstSubscriber = listeners.size === 0;
+      listeners.add(onChange);
+      if (firstSubscriber) {
+        unsubscribeToken = client.onAuthTokenChange(refresh);
+        refresh();
+      }
+      return () => {
+        listeners.delete(onChange);
+        if (listeners.size === 0) {
+          unsubscribeToken?.();
+          unsubscribeToken = void 0;
+        }
+      };
+    }
+  };
+};
+const getStore = (client) => {
+  let store = stores.get(client);
+  if (!store) {
+    store = createStore(client);
+    stores.set(client, store);
+  }
+  return store;
+};
+const useAuth = () => {
+  const $ = c(12);
+  const client = useLunora();
+  let t0;
+  if ($[0] !== client) {
+    t0 = getStore(client);
+    $[0] = client;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const store = t0;
+  let t1;
+  let t2;
+  let t3;
+  if ($[2] !== client) {
+    t1 = (onChange) => client.onAuthTokenChange(onChange);
+    t2 = () => client.getAuthToken();
+    t3 = () => client.getAuthToken();
+    $[2] = client;
+    $[3] = t1;
+    $[4] = t2;
+    $[5] = t3;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+    t3 = $[5];
+  }
+  const token = useSyncExternalStore(t1, t2, t3);
+  const user = useSyncExternalStore(store.subscribe, store.getSnapshot, _temp);
+  let t4;
+  if ($[6] !== client) {
+    t4 = (next) => {
+      client.setAuthToken(next);
+    };
+    $[6] = client;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const setToken = t4;
+  let t5;
+  if ($[8] !== setToken || $[9] !== token || $[10] !== user) {
+    t5 = {
+      setToken,
+      token,
+      user
+    };
+    $[8] = setToken;
+    $[9] = token;
+    $[10] = user;
+    $[11] = t5;
+  } else {
+    t5 = $[11];
+  }
+  return t5;
+};
+function _temp() {
+  return null;
+}
+
+export { useAuth as default };

package/dist/packem_shared/useAuthState-BiGhtSCs.mjs

@@ -0,0 +1,36 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useSyncExternalStore } from 'react';
+import useAuth from './useAuth-CNUKtOOp.mjs';
+
+const subscribe = () => () => void 0;
+const useAuthState = () => {
+  const $ = c(3);
+  const {
+    token
+  } = useAuth();
+  const hydrated = useSyncExternalStore(subscribe, _temp, _temp2);
+  const t0 = hydrated && token !== null;
+  const t1 = !hydrated;
+  let t2;
+  if ($[0] !== t0 || $[1] !== t1) {
+    t2 = {
+      isAuthenticated: t0,
+      isLoading: t1
+    };
+    $[0] = t0;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  return t2;
+};
+function _temp() {
+  return true;
+}
+function _temp2() {
+  return false;
+}
+
+export { useAuthState };

package/dist/packem_shared/useConnectionStatus-DRSY9ldm.mjs

@@ -0,0 +1,30 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useSyncExternalStore } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+
+const useConnectionStatus = () => {
+  const $ = c(4);
+  const client = useLunora();
+  let t0;
+  let t1;
+  let t2;
+  if ($[0] !== client) {
+    t0 = (onChange) => client.onConnectionStatus(() => {
+      onChange();
+    });
+    t1 = () => client.connectionStatus();
+    t2 = () => client.connectionStatus();
+    $[0] = client;
+    $[1] = t0;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t0 = $[1];
+    t1 = $[2];
+    t2 = $[3];
+  }
+  return useSyncExternalStore(t0, t1, t2);
+};
+
+export { useConnectionStatus as default };

package/dist/packem_shared/useFlag-Bg5DpkGv.mjs

@@ -0,0 +1,224 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useState, useRef, useEffect } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+import { s as stableStringify } from './stable-key-CaKZv9lp.mjs';
+
+const FLAGS_EVAL_PATH = "__lunora_flags__:eval";
+const flagKind = (value) => {
+  const kind = typeof value;
+  if (kind === "boolean" || kind === "number" || kind === "string") {
+    return kind;
+  }
+  return "object";
+};
+const flagsReference = {
+  __lunoraRef: FLAGS_EVAL_PATH
+};
+const useFlag = (key, defaultValue, context) => {
+  const $ = c(19);
+  const client = useLunora();
+  const [value, setValue] = useState(defaultValue);
+  let t0;
+  if ($[0] !== defaultValue) {
+    t0 = flagKind(defaultValue);
+    $[0] = defaultValue;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const type = t0;
+  let t1;
+  if ($[2] !== context) {
+    t1 = context === void 0 ? "" : stableStringify(context);
+    $[2] = context;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const serializedContext = t1;
+  let t2;
+  if ($[4] !== context || $[5] !== defaultValue) {
+    t2 = {
+      context,
+      defaultValue
+    };
+    $[4] = context;
+    $[5] = defaultValue;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  const latest = useRef(t2);
+  let t3;
+  if ($[7] !== context || $[8] !== defaultValue) {
+    t3 = () => {
+      latest.current = {
+        context,
+        defaultValue
+      };
+    };
+    $[7] = context;
+    $[8] = defaultValue;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  useEffect(t3);
+  let t4;
+  if ($[10] !== client || $[11] !== key || $[12] !== type) {
+    t4 = () => {
+      let cancelled = false;
+      const {
+        context: currentContext,
+        defaultValue: currentDefault
+      } = latest.current;
+      setValue(currentDefault);
+      let unsubscribe;
+      try {
+        unsubscribe = client.subscribe(flagsReference, {
+          context: currentContext,
+          default: currentDefault,
+          key,
+          type
+        }, (next) => {
+          if (!cancelled) {
+            setValue(next);
+          }
+        });
+      } catch {
+        return () => {
+          cancelled = true;
+        };
+      }
+      return () => {
+        cancelled = true;
+        unsubscribe();
+      };
+    };
+    $[10] = client;
+    $[11] = key;
+    $[12] = type;
+    $[13] = t4;
+  } else {
+    t4 = $[13];
+  }
+  let t5;
+  if ($[14] !== client || $[15] !== key || $[16] !== serializedContext || $[17] !== type) {
+    t5 = [client, key, type, serializedContext];
+    $[14] = client;
+    $[15] = key;
+    $[16] = serializedContext;
+    $[17] = type;
+    $[18] = t5;
+  } else {
+    t5 = $[18];
+  }
+  useEffect(t4, t5);
+  return value;
+};
+const useFlags = (flags, context) => {
+  const $ = c(16);
+  const client = useLunora();
+  const [values, setValues] = useState(flags);
+  let t0;
+  if ($[0] !== flags) {
+    t0 = stableStringify(flags);
+    $[0] = flags;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const spec = t0;
+  let t1;
+  if ($[2] !== context) {
+    t1 = context === void 0 ? "" : stableStringify(context);
+    $[2] = context;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const serializedContext = t1;
+  let t2;
+  if ($[4] !== context || $[5] !== flags) {
+    t2 = {
+      context,
+      flags
+    };
+    $[4] = context;
+    $[5] = flags;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  const latest = useRef(t2);
+  let t3;
+  if ($[7] !== context || $[8] !== flags) {
+    t3 = () => {
+      latest.current = {
+        context,
+        flags
+      };
+    };
+    $[7] = context;
+    $[8] = flags;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  useEffect(t3);
+  let t4;
+  if ($[10] !== client) {
+    t4 = () => {
+      let cancelled = false;
+      const {
+        context: currentContext,
+        flags: currentFlags
+      } = latest.current;
+      setValues(currentFlags);
+      const unsubscribes = [];
+      for (const [key, defaultValue] of Object.entries(currentFlags)) {
+        try {
+          unsubscribes.push(client.subscribe(flagsReference, {
+            context: currentContext,
+            default: defaultValue,
+            key,
+            type: flagKind(defaultValue)
+          }, (next) => {
+            if (!cancelled) {
+              setValues((previous) => ({
+                ...previous,
+                [key]: next
+              }));
+            }
+          }));
+        } catch {
+        }
+      }
+      return () => {
+        cancelled = true;
+        for (const unsubscribe of unsubscribes) {
+          unsubscribe();
+        }
+      };
+    };
+    $[10] = client;
+    $[11] = t4;
+  } else {
+    t4 = $[11];
+  }
+  let t5;
+  if ($[12] !== client || $[13] !== serializedContext || $[14] !== spec) {
+    t5 = [client, spec, serializedContext];
+    $[12] = client;
+    $[13] = serializedContext;
+    $[14] = spec;
+    $[15] = t5;
+  } else {
+    t5 = $[15];
+  }
+  useEffect(t4, t5);
+  return values;
+};
+
+export { useFlag, useFlags };

package/dist/packem_shared/useInfiniteQuery-BBIDFXBN.mjs

@@ -0,0 +1,97 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { useRef, useEffect } from 'react';
+import { u as usePaginatedCore } from './use-paginated-core-DP72UNWn.mjs';
+
+const useInfiniteQuery = (function_, args, options) => {
+  const $ = c(15);
+  const {
+    initialNumItems
+  } = options;
+  const {
+    loadMore,
+    pageResults,
+    status
+  } = usePaginatedCore(function_, args === "skip" ? "skip" : args, options);
+  const skipped = args === "skip";
+  let resolvedPages;
+  if ($[0] !== pageResults) {
+    resolvedPages = [];
+    for (const result of pageResults) {
+      if (result) {
+        resolvedPages.push(result.page);
+      }
+    }
+    $[0] = pageResults;
+    $[1] = resolvedPages;
+  } else {
+    resolvedPages = $[1];
+  }
+  let t0;
+  if ($[2] !== initialNumItems || $[3] !== loadMore) {
+    t0 = {
+      defaultNumItems: initialNumItems,
+      loadMore
+    };
+    $[2] = initialNumItems;
+    $[3] = loadMore;
+    $[4] = t0;
+  } else {
+    t0 = $[4];
+  }
+  const nextRef = useRef(t0);
+  let t1;
+  if ($[5] !== initialNumItems || $[6] !== loadMore) {
+    t1 = () => {
+      nextRef.current = {
+        defaultNumItems: initialNumItems,
+        loadMore
+      };
+    };
+    $[5] = initialNumItems;
+    $[6] = loadMore;
+    $[7] = t1;
+  } else {
+    t1 = $[7];
+  }
+  useEffect(t1);
+  let t2;
+  if ($[8] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t2 = (numberItems) => {
+      const {
+        defaultNumItems,
+        loadMore: load
+      } = nextRef.current;
+      load(numberItems ?? defaultNumItems);
+    };
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  const fetchNextPage = t2;
+  const t3 = status === "CanLoadMore";
+  const t4 = !skipped && status === "LoadingMore";
+  const t5 = !skipped && status === "LoadingFirstPage";
+  let t6;
+  if ($[9] !== resolvedPages || $[10] !== status || $[11] !== t3 || $[12] !== t4 || $[13] !== t5) {
+    t6 = {
+      fetchNextPage,
+      hasNextPage: t3,
+      isFetchingNextPage: t4,
+      isLoading: t5,
+      pages: resolvedPages,
+      status
+    };
+    $[9] = resolvedPages;
+    $[10] = status;
+    $[11] = t3;
+    $[12] = t4;
+    $[13] = t5;
+    $[14] = t6;
+  } else {
+    t6 = $[14];
+  }
+  return t6;
+};
+
+export { useInfiniteQuery as default };

package/dist/packem_shared/useMutation-CrvMXRsk.mjs

@@ -0,0 +1,67 @@
+'use client';
+import { useMutation as useMutation$1 } from '@tanstack/react-query';
+import { useRef, useState, useCallback } from 'react';
+import { useLunora } from './LunoraProvider-D38Xp16l.mjs';
+
+const useMutation = (function_) => {
+  const client = useLunora();
+  const pendingCountRef = useRef(0);
+  const [pending, setPending] = useState(false);
+  const mutation = useMutation$1({
+    mutationFn: ({
+      args,
+      options
+    }) => client.mutation(function_, args, options),
+    // `onMutate` fires when a call starts, `onSettled` when it resolves or
+    // rejects — so overlapping calls compose and `pending` only clears once
+    // the last one settles.
+    onMutate: () => {
+      pendingCountRef.current += 1;
+      setPending(true);
+    },
+    onSettled: () => {
+      pendingCountRef.current -= 1;
+      setPending(pendingCountRef.current > 0);
+    }
+  });
+  const {
+    data,
+    error,
+    isError,
+    mutateAsync,
+    reset
+  } = mutation;
+  const mutate = useCallback((args_0, options_0) => mutateAsync({
+    args: args_0,
+    options: options_0
+  }), [mutateAsync]);
+  const withOptimisticUpdate = useCallback((update) => {
+    const boundMutate = (args_1, options_1) => mutateAsync({
+      args: args_1,
+      options: {
+        optimisticUpdate: update,
+        ...options_1
+      }
+    });
+    return {
+      data,
+      error,
+      isError,
+      mutate: boundMutate,
+      pending,
+      reset,
+      withOptimisticUpdate
+    };
+  }, [mutateAsync, data, error, isError, pending, reset]);
+  return {
+    data,
+    error,
+    isError,
+    mutate,
+    pending,
+    reset,
+    withOptimisticUpdate
+  };
+};
+
+export { useMutation };

package/dist/packem_shared/useMutator-IIrLtDiM.mjs

@@ -0,0 +1,47 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { createMutatorRunner } from '@lunora/client';
+import { useState } from 'react';
+
+const useMutator = function useMutator2(handle) {
+  const $ = c(8);
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState(void 0);
+  let t0;
+  if ($[0] !== handle) {
+    t0 = createMutatorRunner(handle, {
+      setError,
+      setPending
+    });
+    $[0] = handle;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const {
+    mutate,
+    reset
+  } = t0;
+  const t1 = error !== void 0;
+  let t2;
+  if ($[2] !== error || $[3] !== mutate || $[4] !== pending || $[5] !== reset || $[6] !== t1) {
+    t2 = {
+      error,
+      isError: t1,
+      mutate,
+      pending,
+      reset
+    };
+    $[2] = error;
+    $[3] = mutate;
+    $[4] = pending;
+    $[5] = reset;
+    $[6] = t1;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  return t2;
+};
+
+export { useMutator };

package/dist/packem_shared/usePaginatedQuery-AQO3kdp1.mjs

@@ -0,0 +1,46 @@
+'use client';
+import { c } from 'react/compiler-runtime';
+import { u as usePaginatedCore } from './use-paginated-core-DP72UNWn.mjs';
+
+const usePaginatedQuery = (function_, args, options) => {
+  const $ = c(7);
+  const {
+    loadMore,
+    pageResults,
+    status
+  } = usePaginatedCore(function_, args === "skip" ? "skip" : args, options);
+  let results;
+  if ($[0] !== pageResults) {
+    results = [];
+    for (const result of pageResults) {
+      if (result) {
+        results.push(...result.page);
+      }
+    }
+    $[0] = pageResults;
+    $[1] = results;
+  } else {
+    results = $[1];
+  }
+  const skipped = args === "skip";
+  const t0 = !skipped && (status === "LoadingFirstPage" || status === "LoadingMore");
+  let t1;
+  if ($[2] !== loadMore || $[3] !== results || $[4] !== status || $[5] !== t0) {
+    t1 = {
+      isLoading: t0,
+      loadMore,
+      results,
+      status
+    };
+    $[2] = loadMore;
+    $[3] = results;
+    $[4] = status;
+    $[5] = t0;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  return t1;
+};
+
+export { usePaginatedQuery };