@stacksjs/browser 0.70.58 → 0.70.59

package/dist/auto-init.js

@@ -0,0 +1,61 @@
+import {
+  browserQuery,
+  BrowserQueryBuilder,
+  BrowserQueryError,
+  browserAuth,
+  configureBrowser,
+  getBrowserConfig,
+  createBrowserDb,
+  createBrowserModel,
+  isBrowser
+} from "bun-query-builder/browser";
+import * as Composables from "./composables";
+import { loadBrowserModels } from "./model-loader";
+let isInitialized = !1;
+function autoInit() {
+  if (isInitialized)
+    return;
+  if (typeof window > "u")
+    return;
+  if (typeof document > "u")
+    return;
+  isInitialized = !0;
+  const baseUrl = window.__STACKS_API_URL__ || `${window.location.origin}/api`;
+  configureBrowser({
+    baseUrl,
+    getToken: () => {
+      try {
+        return localStorage.getItem("token");
+      } catch {
+        return null;
+      }
+    },
+    onUnauthorized: () => {
+      const loginUrl = window.__STACKS_LOGIN_URL__ || "/login";
+      if (!window.location.pathname.startsWith(loginUrl))
+        window.location.href = loginUrl;
+    },
+    transformResponse: (data) => {
+      return data?.data ?? data;
+    }
+  });
+  window.StacksBrowser = {
+    browserQuery,
+    BrowserQueryBuilder,
+    BrowserQueryError,
+    browserAuth,
+    configureBrowser,
+    getBrowserConfig,
+    createBrowserDb,
+    createBrowserModel,
+    isBrowser,
+    ...Composables
+  };
+  loadBrowserModels();
+  window.dispatchEvent(new CustomEvent("stacks:api-ready"));
+  if (window.__STACKS_DEBUG__)
+    console.debug("[Stacks] Browser API initialized:", baseUrl);
+}
+autoInit();
+
+export { autoInit, isInitialized };

package/dist/composables/auth/useGithub.d.ts

@@ -0,0 +1,12 @@
+import type { Ref } from '@stacksjs/stx';
+export declare function useGitHubOAuth(): GitHubOAuthReturn;
+declare interface GitHubOAuthReturn {
+  login: () => void
+  accessToken: Ref<string | null>
+  error: Ref<string | null>
+  isLoading: Ref<boolean>
+}
+// @ts-ignore - Window.location override
+declare global {
+  interface Window {}
+}

package/dist/composables/auth/useGithub.js

@@ -0,0 +1,41 @@
+import { onMounted, ref } from "@stacksjs/stx";
+export function useGitHubOAuth() {
+  const stacksConfig = window.__STACKS_CONFIG__ || {}, clientId = stacksConfig.GITHUB_CLIENT_ID || "", redirectUri = `${stacksConfig.APP_URL || window.location.origin}/auth/github/callback`, accessToken = ref(null), error = ref(null), isLoading = ref(!1);
+  function login() {
+    const githubAuthUrl = `https://github.com/login/oauth/authorize?client_id=${clientId}&redirect_uri=${encodeURIComponent(redirectUri)}&scope=read:user user:email`;
+    window.location.href = githubAuthUrl;
+  }
+  async function fetchAccessToken(code) {
+    isLoading.value = !0;
+    error.value = null;
+    try {
+      const apiUrl = stacksConfig.APP_URL || window.location.origin, res = await fetch(`${apiUrl}/api/github/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code })
+      });
+      if (!res.ok)
+        throw Error("Failed to exchange code for access token");
+      const data = await res.json();
+      accessToken.value = data.access_token;
+    } catch (err) {
+      error.value = err.message || "Unknown error";
+    } finally {
+      isLoading.value = !1;
+    }
+  }
+  function handleCallback() {
+    const code = new URLSearchParams(window.location.search).get("code");
+    if (code)
+      fetchAccessToken(code);
+  }
+  onMounted(() => {
+    handleCallback();
+  });
+  return {
+    login,
+    accessToken,
+    error,
+    isLoading
+  };
+}

package/dist/composables/index.js

@@ -0,0 +1,110 @@
+export * from "./useAuth";
+export * from "./useApi";
+export {
+  useColorMode,
+  useDark,
+  usePreferredColorScheme,
+  usePreferredContrast,
+  usePreferredDark,
+  usePreferredReducedMotion,
+  useDateFormat,
+  useNow,
+  useTimeAgo,
+  useTimestamp,
+  useFetch,
+  useNetwork,
+  useOnline,
+  useLocalStorage,
+  useSessionStorage,
+  useStorage,
+  useToggle,
+  useCounter,
+  useStepper,
+  useCycleList,
+  useActiveElement,
+  useClipboard,
+  useClipboardItems,
+  useCssVar,
+  useDocumentVisibility,
+  useElementBounding,
+  useElementHover,
+  useElementSize,
+  useElementVisibility,
+  useFocus,
+  useFocusWithin,
+  useFullscreen,
+  useScroll,
+  useScrollLock,
+  useTitle,
+  useWindowFocus,
+  useWindowScroll,
+  useWindowSize,
+  onClickOutside,
+  onKeyDown,
+  onKeyStroke,
+  onKeyUp,
+  onLongPress,
+  onStartTyping,
+  useEventListener,
+  useKeyModifier,
+  useMagicKeys,
+  useDraggable,
+  useDropZone,
+  useMouse,
+  useMouseInElement,
+  useMousePressed,
+  usePointer,
+  usePointerSwipe,
+  useSwipe,
+  useBattery,
+  useDeviceMotion,
+  useDeviceOrientation,
+  useDevicePixelRatio,
+  useGeolocation,
+  useBreakpoints,
+  useMediaQuery,
+  breakpointsTailwind,
+  breakpointsBootstrapV5,
+  useBrowserLocation,
+  useIdle,
+  useInfiniteScroll,
+  useNavigatorLanguage,
+  usePageLeave,
+  usePreferredLanguages,
+  useScreenOrientation,
+  useTextDirection,
+  useTextSelection,
+  useUrlSearchParams,
+  useDebounceFn,
+  useInterval,
+  useIntervalFn,
+  useRafFn,
+  useThrottleFn,
+  useTimeout,
+  useTimeoutFn,
+  useTimeoutPoll,
+  useAnimate,
+  useTransition,
+  TransitionPresets,
+  useBase64,
+  useBroadcastChannel,
+  useConfirmDialog,
+  useEventBus,
+  useEventSource,
+  useEyeDropper,
+  useFavicon,
+  useFileDialog,
+  useImage,
+  useObjectUrl,
+  usePermission,
+  useShare,
+  useVibrate,
+  useWakeLock,
+  useWebNotification,
+  useWebSocket,
+  useWebWorker,
+  useWebWorkerFn,
+  useSupported,
+  useMemoize,
+  useMounted
+} from "@stacksjs/composables";

package/dist/composables/useApi.js

@@ -0,0 +1,66 @@
+import { configureBrowser, browserAuth } from "bun-query-builder/browser";
+export function initApi(options) {
+  const stacksConfig = globalThis.__STACKS_CONFIG__ || {}, baseUrl = options?.baseUrl || (typeof window < "u" ? `${window.location.origin}/api` : `http://localhost:${process.env.PORT_API || "3008"}/api`);
+  configureBrowser({
+    baseUrl,
+    getToken: () => {
+      if (typeof localStorage < "u")
+        return localStorage.getItem("token");
+      return null;
+    },
+    onUnauthorized: options?.onUnauthorized || (() => {
+      if (typeof window < "u")
+        window.location.href = "/login";
+    }),
+    transformResponse: (data) => {
+      return data?.data ?? data;
+    }
+  });
+}
+export const auth = browserAuth;
+export function formatAreaSize(sqMeters) {
+  if (sqMeters >= 1e6)
+    return `${(sqMeters / 1e6).toFixed(2)} km\xB2`;
+  if (sqMeters >= 1e4)
+    return `${(sqMeters / 1e4).toFixed(2)} ha`;
+  return `${sqMeters.toLocaleString()} m\xB2`;
+}
+export function formatDistance(miles) {
+  return `${miles.toFixed(1)} mi`;
+}
+export function formatElevation(feet) {
+  return `${feet.toLocaleString()} ft`;
+}
+export function formatDuration(seconds) {
+  const hours = Math.floor(seconds / 3600), minutes = Math.floor(seconds % 3600 / 60), secs = seconds % 60;
+  if (hours > 0)
+    return `${hours}h ${minutes}m`;
+  if (minutes > 0)
+    return `${minutes}m ${secs}s`;
+  return `${secs}s`;
+}
+export function getRelativeTime(dateString) {
+  const date = new Date(dateString), diffMs = new Date().getTime() - date.getTime(), diffSeconds = Math.floor(diffMs / 1000), diffMinutes = Math.floor(diffSeconds / 60), diffHours = Math.floor(diffMinutes / 60), diffDays = Math.floor(diffHours / 24), diffWeeks = Math.floor(diffDays / 7);
+  if (diffSeconds < 60)
+    return "just now";
+  if (diffMinutes < 60)
+    return `${diffMinutes} minute${diffMinutes === 1 ? "" : "s"} ago`;
+  if (diffHours < 24)
+    return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
+  if (diffDays < 7)
+    return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
+  if (diffWeeks < 4)
+    return `${diffWeeks} week${diffWeeks === 1 ? "" : "s"} ago`;
+  return date.toLocaleDateString();
+}
+export async function fetchData(fetcher, options) {
+  try {
+    return await fetcher();
+  } catch (error) {
+    if (options?.onError)
+      options.onError(error);
+    else
+      console.error("API Error:", error);
+    return options?.fallback;
+  }
+}

package/dist/composables/useAuth.js

@@ -0,0 +1,127 @@
+import { useStorage } from "@stacksjs/composables";
+import { ref } from "@stacksjs/stx";
+const token = useStorage("token", ""), stacksConfig = globalThis.__STACKS_CONFIG__ || {}, baseUrl = stacksConfig.API_URL || (typeof window < "u" ? window.location.origin : `http://localhost:${process.env.PORT_API || "3008"}`), user = ref(null), isAuthenticated = ref(!1);
+export function useAuth() {
+  async function fetchAuthUser() {
+    try {
+      if (!token.value) {
+        isAuthenticated.value = !1;
+        user.value = null;
+        return null;
+      }
+      const response = await fetch(`${baseUrl}/me`, {
+        headers: {
+          Authorization: `Bearer ${token.value}`,
+          Accept: "application/json"
+        }
+      });
+      if (!response.ok) {
+        token.value = "";
+        isAuthenticated.value = !1;
+        user.value = null;
+        return null;
+      }
+      const data = await response.json();
+      user.value = data;
+      isAuthenticated.value = !0;
+      return data;
+    } catch (error) {
+      console.error("Error fetching user:", error);
+      token.value = "";
+      isAuthenticated.value = !1;
+      user.value = null;
+      return null;
+    }
+  }
+  async function checkAuthentication() {
+    try {
+      return await fetchAuthUser() !== null;
+    } catch (error) {
+      console.error("Error checking authentication:", error);
+      return !1;
+    }
+  }
+  async function register(user) {
+    const url = `${baseUrl}/register`, data = await (await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(user)
+    })).json();
+    if (isRegisterError(data))
+      return data;
+    if (isRegisterResponse(data)) {
+      token.value = data.token;
+      return data;
+    }
+    return data;
+  }
+  function isRegisterError(data) {
+    return "errors" in data;
+  }
+  function isRegisterResponse(data) {
+    return "token" in data && "user" in data;
+  }
+  async function login(user) {
+    try {
+      const url = `${baseUrl}/login`, response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(user)
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw Error(errorData.message || `HTTP error! status: ${response.status}`);
+      }
+      const data = await response.json();
+      token.value = data.token;
+      await fetchAuthUser();
+      return data;
+    } catch (error) {
+      return error;
+    }
+  }
+  async function logout() {
+    try {
+      const currentToken = token.value;
+      if (currentToken)
+        await fetch(`${baseUrl}/logout`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${currentToken}`,
+            Accept: "application/json"
+          }
+        });
+    } catch (error) {
+      console.error("Error during logout:", error);
+    } finally {
+      token.value = "";
+      user.value = null;
+      isAuthenticated.value = !1;
+    }
+  }
+  return {
+    user,
+    isAuthenticated,
+    token,
+    getToken: () => token.value,
+    register,
+    login,
+    logout,
+    fetchAuthUser,
+    checkAuthentication
+  };
+}
+export function authGuard(options = {}) {
+  const guest = options.guest ?? !1, { isAuthenticated } = useAuth();
+  if (guest) {
+    if (isAuthenticated.value)
+      window.location.replace("/");
+    return;
+  }
+  if (!isAuthenticated.value)
+    window.location.replace("/login");
+}

package/dist/composables/useFetch.d.ts

@@ -0,0 +1 @@
+export { useFetch } from '@stacksjs/composables';

package/dist/composables/useFetch.js

@@ -0,0 +1 @@
+export { useFetch } from "@stacksjs/composables";