@lunora/solid 0.0.0 → 1.0.0-alpha.1

package/dist/index.mjs

@@ -0,0 +1,11 @@
+export { LunoraContext, useLunora } from './packem_shared/LunoraContext-C9SpKj54.mjs';
+export { AuthLoading, Authenticated, Unauthenticated, createAuth } from './packem_shared/Authenticated-RMT5Q_eE.mjs';
+export { default as createConnectionStatus } from './packem_shared/createConnectionStatus-D8GPatZX.mjs';
+export { createMutation, createMutationForClient } from './packem_shared/createMutationForClient-C7BxzO0y.mjs';
+export { createInfiniteQuery, createPaginatedQuery } from './packem_shared/createInfiniteQuery-DyMvQ2Qy.mjs';
+export { createPresence } from './packem_shared/createPresence-DiAak1Jw.mjs';
+export { createQuery } from './packem_shared/createQuery-D8mdHfyQ.mjs';
+export { createRateLimit } from './packem_shared/createRateLimit-BA2f8XyF.mjs';
+export { createSubscription } from './packem_shared/createSubscription-BM2fw8hw.mjs';
+export { default as hydratePreloaded } from './packem_shared/hydratePreloaded-CaT1kDBH.mjs';
+export { LunoraProvider } from './packem_shared/LunoraProvider-B5BJFk3K.mjs';

package/dist/packem_shared/Authenticated-RMT5Q_eE.mjs

@@ -0,0 +1,73 @@
+import { createComponent, memo } from 'solid-js/web';
+import { getIdentityStore } from '@lunora/client/auth';
+import { Show, createSignal, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const createAuth = () => {
+  const client = useLunora();
+  const store = getIdentityStore(client);
+  const [token, setTokenSignal] = createSignal(client.getAuthToken());
+  const [user, setUserSignal] = createSignal(store.getUser());
+  const unsubToken = client.onAuthTokenChange((next) => {
+    setTokenSignal(() => next);
+  });
+  const unsubUser = store.subscribe(() => {
+    setUserSignal(() => store.getUser());
+  });
+  onCleanup(() => {
+    unsubToken();
+    unsubUser();
+  });
+  const setToken = (next) => {
+    client.setAuthToken(next);
+  };
+  return {
+    setToken,
+    token,
+    user
+  };
+};
+const Authenticated = (props) => {
+  const {
+    token,
+    user
+  } = createAuth();
+  return createComponent(Show, {
+    get when() {
+      return memo(() => token() === null)() ? false : user() !== null;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+const AuthLoading = (props) => {
+  const {
+    token,
+    user
+  } = createAuth();
+  return createComponent(Show, {
+    get when() {
+      return memo(() => token() === null)() ? false : user() === null;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+const Unauthenticated = (props) => {
+  const {
+    token,
+    user
+  } = createAuth();
+  return createComponent(Show, {
+    get when() {
+      return memo(() => token() === null)() ? user() === null : false;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+
+export { AuthLoading, Authenticated, Unauthenticated, createAuth };

package/dist/packem_shared/LunoraContext-C9SpKj54.mjs

@@ -0,0 +1,12 @@
+import { createContext, useContext } from 'solid-js';
+
+const LunoraContext = createContext();
+const useLunora = () => {
+  const client = useContext(LunoraContext);
+  if (!client) {
+    throw new Error("useLunora must be used inside <LunoraProvider />");
+  }
+  return client;
+};
+
+export { LunoraContext, useLunora };

package/dist/packem_shared/LunoraProvider-B5BJFk3K.mjs

@@ -0,0 +1,17 @@
+import { createComponent } from 'solid-js/web';
+import { LunoraContext } from './LunoraContext-C9SpKj54.mjs';
+
+const LunoraProvider = (props) => (
+  // `props.client` is read lazily inside the JSX so Solid tracks it: swapping
+  // the client prop re-provides the new value to descendants.
+  createComponent(LunoraContext.Provider, {
+    get value() {
+      return props.client;
+    },
+    get children() {
+      return props.children;
+    }
+  })
+);
+
+export { LunoraProvider };

package/dist/packem_shared/createConnectionStatus-D8GPatZX.mjs

@@ -0,0 +1,14 @@
+import { createSignal, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const createConnectionStatus = () => {
+  const client = useLunora();
+  const [status, setStatus] = createSignal(client.connectionStatus());
+  const unsubscribe = client.onConnectionStatus((next) => {
+    setStatus(next);
+  });
+  onCleanup(unsubscribe);
+  return status;
+};
+
+export { createConnectionStatus as default };

package/dist/packem_shared/createInfiniteQuery-DyMvQ2Qy.mjs

@@ -0,0 +1,196 @@
+import { initialPages, derivePaginationStatus, rebalance, applyLoadMore } from '@lunora/client/pagination';
+import { createMemo, createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const buildPageArgs = (page, baseArgs) => {
+  return {
+    ...baseArgs,
+    paginationOpts: {
+      cursor: page.lower,
+      endCursor: page.upper,
+      numItems: page.numItems
+    }
+  };
+};
+const buildPageKey = (functionPath, pageArgs) => `${functionPath}::${JSON.stringify(pageArgs)}`;
+const createPaginatedCore = (function_, args, options) => {
+  const client = useLunora();
+  const {
+    initialNumItems,
+    shardKey
+  } = options;
+  const resolveArgs = () => typeof args === "function" ? args() : args;
+  const [pages, setPages] = createSignal(initialPages(initialNumItems));
+  const resultsByKey = /* @__PURE__ */ new Map();
+  const [pageResults, setPageResults] = createSignal([]);
+  const activeSubs = /* @__PURE__ */ new Map();
+  const pendingPageKeys = /* @__PURE__ */ new Set();
+  const rebuildPageResults = (currentPages, baseArgs) => {
+    const updated = currentPages.map((page) => {
+      const key = buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs));
+      return resultsByKey.get(key);
+    });
+    setPageResults(updated);
+  };
+  const syncSubscriptions = (currentPages, baseArgs) => {
+    const wantedKeys = /* @__PURE__ */ new Set();
+    for (const page of currentPages) {
+      wantedKeys.add(buildPageKey(function_["__lunoraRef"], buildPageArgs(page, baseArgs)));
+    }
+    for (const [key, unsub] of activeSubs) {
+      if (!wantedKeys.has(key)) {
+        unsub();
+        activeSubs.delete(key);
+        pendingPageKeys.delete(key);
+      }
+    }
+    for (const page of currentPages) {
+      const pageArgs = buildPageArgs(page, baseArgs);
+      const key = buildPageKey(function_["__lunoraRef"], pageArgs);
+      if (activeSubs.has(key)) {
+        continue;
+      }
+      pendingPageKeys.add(key);
+      const unsub = client.subscribe(function_, pageArgs, (value) => {
+        resultsByKey.set(key, value);
+        pendingPageKeys.delete(key);
+        const currentArgs = resolveArgs();
+        if (currentArgs === "skip") {
+          return;
+        }
+        rebuildPageResults(pages(), currentArgs);
+        if (pendingPageKeys.size === 0) {
+          const next = rebalance(pages(), pageResults());
+          if (next) {
+            setPages(next);
+          }
+        }
+      }, {
+        shardKey
+      });
+      activeSubs.set(key, unsub);
+    }
+  };
+  const teardownAll = () => {
+    for (const unsub of activeSubs.values()) {
+      unsub();
+    }
+    activeSubs.clear();
+    resultsByKey.clear();
+    pendingPageKeys.clear();
+  };
+  createEffect(on(resolveArgs, (current) => {
+    teardownAll();
+    setPages(initialPages(initialNumItems));
+    setPageResults([]);
+    if (current !== "skip") {
+      syncSubscriptions(pages(), current);
+      rebuildPageResults(pages(), current);
+    }
+    onCleanup(teardownAll);
+  }));
+  createEffect(on(pages, (currentPages) => {
+    const current = resolveArgs();
+    if (current !== "skip") {
+      syncSubscriptions(currentPages, current);
+      rebuildPageResults(currentPages, current);
+    }
+  }));
+  const status = createMemo(() => {
+    const skipped = resolveArgs() === "skip";
+    return derivePaginationStatus(skipped, pageResults()).status;
+  });
+  const loadMore = (numberItems) => {
+    const current = resolveArgs();
+    if (current === "skip") {
+      return;
+    }
+    const {
+      nextCursor,
+      status: currentStatus
+    } = derivePaginationStatus(false, pageResults());
+    if (currentStatus !== "CanLoadMore") {
+      return;
+    }
+    const next = applyLoadMore(pages(), nextCursor, numberItems);
+    if (!next) {
+      return;
+    }
+    const oldTail = pages().at(-1);
+    const newPinnedPage = next.at(-2);
+    if (oldTail && newPinnedPage) {
+      const oldKey = buildPageKey(function_["__lunoraRef"], buildPageArgs(oldTail, current));
+      const newKey = buildPageKey(function_["__lunoraRef"], buildPageArgs(newPinnedPage, current));
+      if (oldKey !== newKey) {
+        const carried = resultsByKey.get(oldKey);
+        if (carried) {
+          resultsByKey.set(newKey, carried);
+        }
+      }
+    }
+    setPages(next);
+  };
+  return {
+    loadMore,
+    pageResults,
+    status
+  };
+};
+const createPaginatedQuery = (function_, args, options) => {
+  const {
+    loadMore,
+    pageResults,
+    status
+  } = createPaginatedCore(function_, args, options);
+  const results = createMemo(() => {
+    const items = [];
+    for (const page of pageResults()) {
+      if (page) {
+        items.push(...page.page);
+      }
+    }
+    return items;
+  });
+  const isLoading = createMemo(() => status() === "LoadingFirstPage" || status() === "LoadingMore");
+  return {
+    isLoading,
+    loadMore,
+    results,
+    status
+  };
+};
+const createInfiniteQuery = (function_, args, options) => {
+  const {
+    initialNumItems
+  } = options;
+  const {
+    loadMore,
+    pageResults,
+    status
+  } = createPaginatedCore(function_, args, options);
+  const pages = createMemo(() => {
+    const result = [];
+    for (const page of pageResults()) {
+      if (page) {
+        result.push(page.page);
+      }
+    }
+    return result;
+  });
+  const isLoading = createMemo(() => status() === "LoadingFirstPage");
+  const hasNextPage = createMemo(() => status() === "CanLoadMore");
+  const isFetchingNextPage = createMemo(() => status() === "LoadingMore");
+  const fetchNextPage = (numberItems) => {
+    loadMore(numberItems ?? initialNumItems);
+  };
+  return {
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage,
+    isLoading,
+    pages,
+    status
+  };
+};
+
+export { createInfiniteQuery, createPaginatedQuery };

package/dist/packem_shared/createMutationForClient-C7BxzO0y.mjs

@@ -0,0 +1,36 @@
+import { createMutationRunner } from '@lunora/client';
+import { createSignal } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const createMutationForClient = (client, function_) => {
+  const [data, setData] = createSignal(void 0);
+  const [error, setError] = createSignal(void 0);
+  const [pending, setPending] = createSignal(false);
+  const mutate = createMutationRunner(client, function_, {
+    setError,
+    setPending,
+    setResult: (result) => {
+      setData(() => result);
+      setError(void 0);
+    }
+  });
+  const reset = () => {
+    setData(() => void 0);
+    setError(void 0);
+  };
+  return {
+    data,
+    error,
+    mutate,
+    pending,
+    reset
+  };
+};
+const createMutation = (function_) => {
+  const client = useLunora();
+  return createMutationForClient({
+    mutation: (reference, args, options) => client.mutation(reference, args, options)
+  }, function_);
+};
+
+export { createMutation, createMutationForClient };

package/dist/packem_shared/createPresence-DiAak1Jw.mjs

@@ -0,0 +1,78 @@
+import { createSignal, onMount, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const makeSessionId = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `sess-${Math.random().toString(36).slice(2)}-${String(Date.now())}`;
+};
+const DEFAULT_INTERVAL_MS = 1e4;
+const createPresence = (roomId, options) => {
+  const client = useLunora();
+  const {
+    heartbeat,
+    intervalMs = DEFAULT_INTERVAL_MS,
+    listPresent,
+    shardKey
+  } = options;
+  const sessionId = options.sessionId ?? makeSessionId();
+  const [present, setPresent] = createSignal(void 0);
+  let latestData = options.data;
+  const sendHeartbeat = () => {
+    const args = {
+      roomId,
+      sessionId,
+      ...latestData === void 0 ? {} : {
+        data: latestData
+      }
+    };
+    client.mutation(heartbeat, args, {
+      shardKey
+    }).catch(() => void 0);
+  };
+  const setData = (next) => {
+    latestData = next;
+    sendHeartbeat();
+  };
+  onMount(() => {
+    sendHeartbeat();
+    const intervalHandle = setInterval(sendHeartbeat, intervalMs);
+    const onVisible = () => {
+      if (typeof document !== "undefined" && document.visibilityState === "visible") {
+        sendHeartbeat();
+      }
+    };
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", onVisible);
+    }
+    const releaseConnectionContext = client.acquireConnectionContext({
+      roomId,
+      sessionId
+    }, {
+      shardKey
+    });
+    const unsubscribe = client.subscribe(listPresent, {
+      roomId
+    }, (value) => {
+      setPresent(() => value);
+    }, {
+      shardKey
+    });
+    onCleanup(() => {
+      clearInterval(intervalHandle);
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", onVisible);
+      }
+      releaseConnectionContext();
+      unsubscribe();
+    });
+  });
+  return {
+    present,
+    sessionId,
+    setData
+  };
+};
+
+export { createPresence };

package/dist/packem_shared/createQuery-D8mdHfyQ.mjs

@@ -0,0 +1,28 @@
+import { createQuerySubscription } from '@lunora/client/query';
+import { createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const createQuery = (function_, args, options = {}) => {
+  const client = useLunora();
+  const {
+    shardKey
+  } = options;
+  const [value, setValue] = createSignal(void 0);
+  const resolveArgs = () => typeof args === "function" ? args() : args;
+  createEffect(on(resolveArgs, (current) => {
+    const unsubscribe = createQuerySubscription(client, function_, current, {
+      onData: (next) => {
+        setValue(() => next);
+      },
+      onReset: () => {
+        setValue(() => void 0);
+      }
+    }, {
+      shardKey
+    });
+    onCleanup(unsubscribe);
+  }));
+  return value;
+};
+
+export { createQuery };

package/dist/packem_shared/createRateLimit-BA2f8XyF.mjs

@@ -0,0 +1,76 @@
+import { evaluate } from '@lunora/ratelimit';
+import { createSignal, createMemo, onCleanup } from 'solid-js';
+
+const createRateLimit = (config, options = {}) => {
+  const now = options.now ?? Date.now;
+  const tickMs = options.tickMs ?? 1e3;
+  let value;
+  const [epoch, setEpoch] = createSignal(0);
+  const bump = () => {
+    setEpoch((n) => n + 1);
+  };
+  const status = createMemo(() => {
+    const ts = now() + epoch() * 0;
+    return evaluate(config, value, {
+      consume: false,
+      count: 1,
+      now: ts,
+      reserve: false
+    }).status;
+  });
+  let intervalHandle;
+  const stopInterval = () => {
+    if (intervalHandle !== void 0) {
+      clearInterval(intervalHandle);
+      intervalHandle = void 0;
+    }
+  };
+  const startIntervalIfThrottled = () => {
+    if (status().ok || intervalHandle !== void 0) {
+      return;
+    }
+    intervalHandle = setInterval(() => {
+      bump();
+      if (status().ok) {
+        stopInterval();
+      }
+    }, tickMs);
+  };
+  onCleanup(stopInterval);
+  startIntervalIfThrottled();
+  const consume = (count = 1) => {
+    const result = evaluate(config, value, {
+      consume: true,
+      count,
+      now: now(),
+      reserve: false
+    });
+    if (result.value !== void 0) {
+      value = result.value;
+    }
+    bump();
+    startIntervalIfThrottled();
+    return result.status;
+  };
+  const check = (count = 1) => evaluate(config, value, {
+    consume: false,
+    count,
+    now: now(),
+    reserve: false
+  }).status.ok;
+  const reset = () => {
+    value = void 0;
+    stopInterval();
+    bump();
+  };
+  return {
+    check,
+    consume,
+    disabled: () => !status().ok,
+    ok: () => status().ok,
+    reset,
+    retryAfter: () => status().retryAfter
+  };
+};
+
+export { createRateLimit };

package/dist/packem_shared/createSubscription-BM2fw8hw.mjs

@@ -0,0 +1,39 @@
+import { createQuerySubscription } from '@lunora/client/query';
+import { createSignal, createEffect, on, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const createSubscription = (function_, args, options = {}) => {
+  const client = useLunora();
+  const [data, setData] = createSignal(void 0);
+  const [error, setError] = createSignal(void 0);
+  const resolveArgs = typeof args === "function" ? args : () => args;
+  createEffect(on(resolveArgs, (currentArgs) => {
+    if (currentArgs === "skip") {
+      setData(() => void 0);
+      setError(() => void 0);
+      return;
+    }
+    const unsubscribe = createQuerySubscription(client, function_, currentArgs, {
+      onData: (value) => {
+        setData(() => value);
+        setError(() => void 0);
+      },
+      onError: (subscriptionError) => {
+        setError(() => new Error(subscriptionError.message));
+        setData(() => void 0);
+      },
+      onReset: () => {
+        setData(() => void 0);
+      }
+    }, {
+      shardKey: options.shardKey
+    });
+    onCleanup(unsubscribe);
+  }));
+  return {
+    data,
+    error
+  };
+};
+
+export { createSubscription };

package/dist/packem_shared/hydratePreloaded-CaT1kDBH.mjs

@@ -0,0 +1,25 @@
+import { createSignal, createEffect, onCleanup } from 'solid-js';
+import { useLunora } from './LunoraContext-C9SpKj54.mjs';
+
+const hydratePreloaded = (preloaded) => {
+  const client = useLunora();
+  const {
+    args,
+    functionPath,
+    shardKey,
+    value
+  } = preloaded;
+  const [data, setData] = createSignal(value);
+  const functionRef = {
+    __lunoraRef: functionPath
+  };
+  createEffect(() => {
+    const unsubscribe = client.subscribe(functionRef, args, (next) => setData(() => next), {
+      shardKey
+    });
+    onCleanup(unsubscribe);
+  });
+  return data;
+};
+
+export { hydratePreloaded as default };

package/dist/server.d.mts

@@ -0,0 +1 @@
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.d.ts

@@ -0,0 +1 @@
+export { type ArgsOf, type AuthLike, type FunctionReference, type HeadersSource, type Preloaded, type ReturnOf, type ServerClientOptions, type ServerSession, createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';

package/dist/server.mjs

@@ -0,0 +1 @@
+export { createServerClient, deserializePreloaded, getServerSession, preloadQuery, preloadedQueryResult, serializePreloaded } from '@lunora/client/ssr';