@flightdev/data 0.0.6

package/dist/index.js

@@ -0,0 +1,463 @@
+import {
+  LRUCache,
+  asyncData,
+  cancelRequest,
+  clearCache,
+  configureCache,
+  createFetchHydrationScript,
+  fetchData,
+  getCache,
+  getCachedData,
+  hydrateFetchData,
+  invalidate,
+  invalidateCache,
+  isClient,
+  isServer,
+  prefetch,
+  setCachedData
+} from "./chunk-NOWQL3EM.js";
+
+// src/hooks.ts
+var isBrowser = typeof window !== "undefined";
+var loaderDataStore = /* @__PURE__ */ new Map();
+var actionDataStore = /* @__PURE__ */ new Map();
+function setLoaderData(key, data) {
+  loaderDataStore.set(key, data);
+}
+function getLoaderData(key) {
+  return loaderDataStore.get(key);
+}
+function setActionData(key, data) {
+  actionDataStore.set(key, data);
+}
+function getActionData(key) {
+  return actionDataStore.get(key);
+}
+function clearDataStores() {
+  loaderDataStore.clear();
+  actionDataStore.clear();
+}
+function getCurrentPathname() {
+  if (isBrowser) {
+    return window.location.pathname;
+  }
+  return "/";
+}
+function getHydratedLoaderData(pathname) {
+  if (!isBrowser) return void 0;
+  const hydrated = window.__FLIGHT_LOADER_DATA__;
+  if (!hydrated) return void 0;
+  const key = pathname ?? getCurrentPathname();
+  return hydrated[key];
+}
+function getHydratedActionData() {
+  if (!isBrowser) return void 0;
+  return window.__FLIGHT_ACTION_DATA__;
+}
+function use(promise) {
+  const thenable = promise;
+  if (thenable.status === "fulfilled") {
+    return thenable.value;
+  }
+  if (thenable.status === "rejected") {
+    throw thenable.reason;
+  }
+  if (thenable.status !== "pending") {
+    thenable.status = "pending";
+    thenable.then(
+      (value) => {
+        thenable.status = "fulfilled";
+        thenable.value = value;
+      },
+      (error) => {
+        thenable.status = "rejected";
+        thenable.reason = error instanceof Error ? error : new Error(String(error));
+      }
+    );
+  }
+  throw thenable;
+}
+var reactHooks = null;
+function getReactHooks() {
+  if (reactHooks) return reactHooks;
+  let React;
+  if (typeof globalThis !== "undefined") {
+    const maybeReact = globalThis.React;
+    if (maybeReact && typeof maybeReact.useState === "function" && typeof maybeReact.useCallback === "function") {
+      React = maybeReact;
+    }
+  }
+  if (!React && isBrowser) {
+    const win = window;
+    if (win.React) {
+      const maybeReact = win.React;
+      if (maybeReact && typeof maybeReact.useState === "function" && typeof maybeReact.useCallback === "function") {
+        React = maybeReact;
+      }
+    }
+  }
+  if (!React) {
+    return null;
+  }
+  const { useState, useCallback } = React;
+  reactHooks = {
+    /**
+     * useLoaderData - Access loader data from SSR or context
+     */
+    useLoaderData: function useFlightLoaderData() {
+      const [data] = useState(() => {
+        const hydrated = getHydratedLoaderData();
+        if (hydrated !== void 0) return hydrated;
+        const stored = getLoaderData(getCurrentPathname());
+        if (stored !== void 0) return stored;
+        return void 0;
+      });
+      return data;
+    },
+    /**
+     * useActionData - Access action result from form submission
+     */
+    useActionData: function useFlightActionData() {
+      const [data] = useState(() => {
+        const hydrated = getHydratedActionData();
+        if (hydrated !== void 0) return hydrated;
+        const stored = getActionData(getCurrentPathname());
+        if (stored !== void 0) return stored;
+        return void 0;
+      });
+      return data;
+    },
+    /**
+     * useFetcher - Client-side data fetching without navigation
+     */
+    useFetcher: function useFlightFetcher() {
+      const [state, setState] = useState({
+        state: "idle",
+        data: void 0,
+        error: void 0
+      });
+      const reset = useCallback(() => {
+        setState({ state: "idle", data: void 0, error: void 0 });
+      }, []);
+      const submit = useCallback(async (formData, options = {}) => {
+        const { method = "POST", action = getCurrentPathname() } = options;
+        setState({ state: "loading", data: void 0, error: void 0 });
+        try {
+          const body = formData instanceof FormData ? formData : new URLSearchParams(formData);
+          const headers = {};
+          if (!(formData instanceof FormData)) {
+            headers["Content-Type"] = "application/x-www-form-urlencoded";
+          }
+          const response = await fetch(action, {
+            method,
+            body,
+            headers: Object.keys(headers).length > 0 ? headers : void 0
+          });
+          if (!response.ok) {
+            throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+          }
+          const contentType = response.headers.get("Content-Type") ?? "";
+          let result;
+          if (contentType.includes("application/json")) {
+            result = await response.json();
+          } else {
+            result = await response.text();
+          }
+          setState({ state: "success", data: result, error: void 0 });
+        } catch (error) {
+          setState({
+            state: "error",
+            data: void 0,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+      }, []);
+      const load = useCallback(async (href) => {
+        setState({ state: "loading", data: void 0, error: void 0 });
+        try {
+          const response = await fetch(href, {
+            headers: { "Accept": "application/json" }
+          });
+          if (!response.ok) {
+            throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+          }
+          const contentType = response.headers.get("Content-Type") ?? "";
+          let result;
+          if (contentType.includes("application/json")) {
+            result = await response.json();
+          } else {
+            result = await response.text();
+          }
+          setState({ state: "success", data: result, error: void 0 });
+        } catch (error) {
+          setState({
+            state: "error",
+            data: void 0,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+      }, []);
+      return {
+        state: state.state,
+        data: state.state === "success" ? state.data : void 0,
+        error: state.state === "error" ? state.error : void 0,
+        submit,
+        load,
+        reset
+      };
+    }
+  };
+  return reactHooks;
+}
+function useLoaderData() {
+  const hooks = getReactHooks();
+  if (hooks) {
+    return hooks.useLoaderData();
+  }
+  const hydrated = getHydratedLoaderData();
+  if (hydrated !== void 0) return hydrated;
+  return getLoaderData(getCurrentPathname());
+}
+function useActionData() {
+  const hooks = getReactHooks();
+  if (hooks) {
+    return hooks.useActionData();
+  }
+  const hydrated = getHydratedActionData();
+  if (hydrated !== void 0) return hydrated;
+  return getActionData(getCurrentPathname());
+}
+function useFetcher() {
+  const hooks = getReactHooks();
+  if (hooks) {
+    return hooks.useFetcher();
+  }
+  console.warn("[Flight] useFetcher called outside React context. Returning static implementation.");
+  return {
+    state: "idle",
+    data: void 0,
+    error: void 0,
+    submit: () => {
+      console.warn("[Flight] useFetcher.submit() called outside React context");
+    },
+    load: () => {
+      console.warn("[Flight] useFetcher.load() called outside React context");
+    },
+    reset: () => {
+    }
+  };
+}
+function createHydrationScript(pathname, loaderData, actionData) {
+  const script = ["<script>"];
+  if (loaderData !== void 0) {
+    script.push(
+      `window.__FLIGHT_LOADER_DATA__ = window.__FLIGHT_LOADER_DATA__ || {};`,
+      `window.__FLIGHT_LOADER_DATA__[${JSON.stringify(pathname)}] = ${JSON.stringify(loaderData)};`
+    );
+  }
+  if (actionData !== void 0) {
+    script.push(
+      `window.__FLIGHT_ACTION_DATA__ = ${JSON.stringify(actionData)};`
+    );
+  }
+  script.push("</script>");
+  return script.join("\n");
+}
+function hydrateFromWindow() {
+  if (!isBrowser) return;
+  const loaderData = window.__FLIGHT_LOADER_DATA__;
+  if (loaderData) {
+    for (const [key, value] of Object.entries(loaderData)) {
+      setLoaderData(key, value);
+    }
+  }
+  const actionData = window.__FLIGHT_ACTION_DATA__;
+  if (actionData !== void 0) {
+    setActionData(getCurrentPathname(), actionData);
+  }
+}
+
+// src/form.ts
+var isBrowser2 = typeof window !== "undefined";
+var Form = null;
+if (typeof globalThis !== "undefined") {
+  try {
+    const React = globalThis.React;
+    if (React?.createElement) {
+      const { useState, useCallback } = React;
+      Form = function FlightForm({
+        action,
+        method = "post",
+        children,
+        className,
+        onSuccess,
+        onError,
+        replace = false,
+        encType = "application/x-www-form-urlencoded"
+      }) {
+        const [isSubmitting, setIsSubmitting] = useState(false);
+        const handleSubmit = useCallback(async (e) => {
+          e.preventDefault();
+          if (!isBrowser2) return;
+          const form = e.target;
+          const formData = new FormData(form);
+          const targetAction = action || form.action || window.location.pathname;
+          const targetMethod = method.toUpperCase();
+          setIsSubmitting(true);
+          try {
+            const response = await fetch(targetAction, {
+              method: targetMethod,
+              body: encType === "multipart/form-data" ? formData : new URLSearchParams(formData),
+              headers: encType === "multipart/form-data" ? void 0 : { "Content-Type": "application/x-www-form-urlencoded" }
+            });
+            if (response.redirected) {
+              const redirectUrl = response.url;
+              if (replace) {
+                window.history.replaceState(null, "", redirectUrl);
+              } else {
+                window.history.pushState(null, "", redirectUrl);
+              }
+              window.dispatchEvent(new PopStateEvent("popstate"));
+              window.scrollTo({ top: 0, left: 0, behavior: "instant" });
+              return;
+            }
+            const location = response.headers.get("Location");
+            if (location) {
+              if (replace) {
+                window.history.replaceState(null, "", location);
+              } else {
+                window.history.pushState(null, "", location);
+              }
+              window.dispatchEvent(new PopStateEvent("popstate"));
+              window.scrollTo({ top: 0, left: 0, behavior: "instant" });
+              return;
+            }
+            if (!response.ok) {
+              throw new Error(`Form submission failed: ${response.status}`);
+            }
+            const contentType = response.headers.get("Content-Type") || "";
+            let data;
+            if (contentType.includes("application/json")) {
+              data = await response.json();
+            } else {
+              data = await response.text();
+            }
+            window.__FLIGHT_ACTION_DATA__ = data;
+            onSuccess?.(data);
+          } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            onError?.(err);
+          } finally {
+            setIsSubmitting(false);
+          }
+        }, [action, method, encType, replace, onSuccess, onError]);
+        return React.createElement("form", {
+          action,
+          method,
+          className,
+          encType,
+          onSubmit: handleSubmit,
+          "data-submitting": isSubmitting || void 0
+        }, children);
+      };
+    }
+  } catch {
+  }
+}
+
+// src/response.ts
+function redirect(url, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("Location", url);
+  return new Response(null, {
+    ...init,
+    status: init?.status || 302,
+    headers
+  });
+}
+function json(data, init) {
+  const headers = new Headers(init?.headers);
+  headers.set("Content-Type", "application/json; charset=utf-8");
+  return new Response(JSON.stringify(data), {
+    ...init,
+    headers
+  });
+}
+function defer(data) {
+  return Object.assign(data, { __deferred: true });
+}
+function isRedirectResponse(response) {
+  return response.status >= 300 && response.status < 400 && response.headers.has("Location");
+}
+function isJsonResponse(response) {
+  const contentType = response.headers.get("Content-Type") || "";
+  return contentType.includes("application/json");
+}
+
+// src/server.ts
+async function runLoader(loader, context) {
+  try {
+    const result = await loader(context);
+    return result;
+  } catch (error) {
+    console.error("Loader error:", error);
+    throw error;
+  }
+}
+async function runAction(action, context) {
+  try {
+    const result = await action(context);
+    if (result instanceof Response) {
+      return result;
+    }
+    return result;
+  } catch (error) {
+    console.error("Action error:", error);
+    throw error;
+  }
+}
+function hydrateLoaderData(pathname, data) {
+  const serialized = JSON.stringify(data).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+  return `<script>
+window.__FLIGHT_LOADER_DATA__ = window.__FLIGHT_LOADER_DATA__ || {};
+window.__FLIGHT_LOADER_DATA__["${pathname}"] = ${serialized};
+</script>`;
+}
+export {
+  Form,
+  LRUCache,
+  asyncData,
+  cancelRequest,
+  clearCache,
+  clearDataStores,
+  configureCache,
+  createFetchHydrationScript,
+  createHydrationScript,
+  defer,
+  fetchData,
+  getActionData,
+  getCache,
+  getCachedData,
+  getLoaderData,
+  hydrateFetchData,
+  hydrateFromWindow,
+  hydrateLoaderData,
+  invalidate,
+  invalidateCache,
+  isClient,
+  isJsonResponse,
+  isRedirectResponse,
+  isServer,
+  json,
+  prefetch,
+  redirect,
+  runAction,
+  runLoader,
+  setActionData,
+  setCachedData,
+  setLoaderData,
+  use,
+  useActionData,
+  useFetcher,
+  useLoaderData
+};

package/dist/react.d.ts

@@ -0,0 +1,57 @@
+import { U as UseFetchOptions, k as UseFetchReturn, l as UseAsyncDataOptions, m as UseAsyncDataReturn } from './cache-DU1v4CKe.js';
+export { q as clearCache, o as configureCache, g as getCachedData, i as invalidate, r as invalidateCache, p as prefetch, s as setCachedData } from './cache-DU1v4CKe.js';
+
+/**
+ * @flightdev/data - React Adapter
+ *
+ * React hooks for data fetching using Flight's core.
+ * Uses React 18+ hooks: useState, useEffect, useCallback, useRef.
+ *
+ * @module @flightdev/data/react
+ */
+
+/**
+ * React hook for data fetching with caching and deduplication
+ *
+ * @example
+ * ```tsx
+ * function Users() {
+ *     const { data, pending, error, refresh } = useFetch<User[]>('/api/users');
+ *
+ *     if (pending) return <p>Loading...</p>;
+ *     if (error) return <p>Error: {error.message}</p>;
+ *
+ *     return <ul>{data.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
+ * }
+ * ```
+ */
+declare function useFetch<T = unknown>(url: string | null, options?: UseFetchOptions<T>): UseFetchReturn<T>;
+/**
+ * React hook for custom async data fetching
+ *
+ * @example
+ * ```tsx
+ * function Analytics() {
+ *     const { data, pending, execute } = useAsyncData(
+ *         'analytics-weekly',
+ *         () => analyticsAPI.getWeeklyReport()
+ *     );
+ *
+ *     return (
+ *         <div>
+ *             <button onClick={execute}>Refresh</button>
+ *             {pending ? <Spinner /> : <Chart data={data} />}
+ *         </div>
+ *     );
+ * }
+ * ```
+ */
+declare function useAsyncData<T = unknown>(key: string, fetcher: () => Promise<T>, options?: UseAsyncDataOptions<T>): UseAsyncDataReturn<T>;
+
+/**
+ * Hydrate data on client startup
+ * Call this before React hydration
+ */
+declare function hydrateFlightData(): void;
+
+export { hydrateFlightData, useAsyncData, useFetch };

package/dist/react.js

@@ -0,0 +1,119 @@
+import {
+  asyncData,
+  clearCache,
+  configureCache,
+  fetchData,
+  getCachedData,
+  hydrateFetchData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData
+} from "./chunk-NOWQL3EM.js";
+
+// src/react.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+var isBrowser = typeof window !== "undefined";
+function useFetch(url, options = {}) {
+  const { immediate = true } = options;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [state, setState] = useState({
+    data: options.default,
+    error: void 0,
+    status: "idle",
+    isStale: false
+  });
+  const [pending, setPending] = useState(immediate && !!url);
+  const execute = useCallback(async () => {
+    if (!url) return;
+    setPending(true);
+    const result = await fetchData(url, optionsRef.current);
+    setState(result);
+    setPending(false);
+  }, [url]);
+  const refresh = useCallback(async () => {
+    if (!url) return;
+    const key = optionsRef.current.key ?? url;
+    invalidate(key);
+    await execute();
+  }, [url, execute]);
+  useEffect(() => {
+    if (immediate && url) {
+      execute();
+    }
+  }, [immediate, url, execute]);
+  useEffect(() => {
+    if (!optionsRef.current.revalidateOnFocus || !isBrowser) return;
+    const onFocus = () => execute();
+    window.addEventListener("focus", onFocus);
+    return () => window.removeEventListener("focus", onFocus);
+  }, [execute]);
+  useEffect(() => {
+    if (!optionsRef.current.revalidateOnReconnect || !isBrowser) return;
+    const onOnline = () => execute();
+    window.addEventListener("online", onOnline);
+    return () => window.removeEventListener("online", onOnline);
+  }, [execute]);
+  return {
+    data: state.data,
+    pending,
+    error: state.error,
+    status: state.status,
+    isStale: state.isStale,
+    refresh,
+    execute
+  };
+}
+function useAsyncData(key, fetcher, options = {}) {
+  const { immediate = true } = options;
+  const optionsRef = useRef(options);
+  const fetcherRef = useRef(fetcher);
+  optionsRef.current = options;
+  fetcherRef.current = fetcher;
+  const [state, setState] = useState({
+    data: options.default,
+    error: void 0,
+    status: "idle",
+    isStale: false
+  });
+  const [pending, setPending] = useState(immediate);
+  const execute = useCallback(async () => {
+    setPending(true);
+    const result = await asyncData(key, fetcherRef.current, optionsRef.current);
+    setState(result);
+    setPending(false);
+  }, [key]);
+  const refresh = useCallback(async () => {
+    invalidate(key);
+    await execute();
+  }, [key, execute]);
+  useEffect(() => {
+    if (immediate) {
+      execute();
+    }
+  }, [immediate, execute]);
+  return {
+    data: state.data,
+    pending,
+    error: state.error,
+    status: state.status,
+    execute,
+    refresh
+  };
+}
+function hydrateFlightData() {
+  hydrateFetchData();
+}
+export {
+  clearCache,
+  configureCache,
+  getCachedData,
+  hydrateFlightData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData,
+  useAsyncData,
+  useFetch
+};