@flightdev/data 0.0.6

package/dist/solid.d.ts

@@ -0,0 +1,83 @@
+import { j as FetchState, U as UseFetchOptions, l as UseAsyncDataOptions } 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 - Solid Adapter
+ *
+ * Solid.js primitives for data fetching using Flight's core.
+ * Uses Solid signals: createSignal, createEffect, onMount, onCleanup.
+ *
+ * @module @flightdev/data/solid
+ */
+
+type Accessor<T> = () => T;
+interface UseFetchReturn<T> {
+    data: Accessor<T | undefined>;
+    pending: Accessor<boolean>;
+    error: Accessor<Error | undefined>;
+    status: Accessor<FetchState<T>['status']>;
+    isStale: Accessor<boolean>;
+    refresh: () => Promise<void>;
+    execute: () => Promise<void>;
+}
+interface UseAsyncDataReturn<T> {
+    data: Accessor<T | undefined>;
+    pending: Accessor<boolean>;
+    error: Accessor<Error | undefined>;
+    status: Accessor<FetchState<T>['status']>;
+    execute: () => Promise<void>;
+    refresh: () => Promise<void>;
+}
+/**
+ * Solid primitive for data fetching with caching and deduplication
+ *
+ * @example
+ * ```tsx
+ * import { useFetch } from '@flightdev/data/solid';
+ *
+ * function Users() {
+ *     const { data, pending, error, refresh } = useFetch('/api/users');
+ *
+ *     return (
+ *         <Show when={!pending()} fallback={<p>Loading...</p>}>
+ *             <ul>
+ *                 <For each={data()}>{user => <li>{user.name}</li>}</For>
+ *             </ul>
+ *         </Show>
+ *     );
+ * }
+ * ```
+ */
+declare function useFetch<T = unknown>(url: string | Accessor<string | null>, options?: UseFetchOptions<T>): UseFetchReturn<T>;
+/**
+ * Solid primitive for custom async data fetching
+ *
+ * @example
+ * ```tsx
+ * import { useAsyncData } from '@flightdev/data/solid';
+ *
+ * function Analytics() {
+ *     const { data, pending, execute } = useAsyncData(
+ *         'analytics',
+ *         () => analyticsAPI.getReport()
+ *     );
+ *
+ *     return (
+ *         <div>
+ *             <button onClick={execute}>Refresh</button>
+ *             <Show when={!pending()} fallback={<Spinner />}>
+ *                 <Chart data={data()} />
+ *             </Show>
+ *         </div>
+ *     );
+ * }
+ * ```
+ */
+declare function useAsyncData<T = unknown>(key: string, fetcher: () => Promise<T>, options?: UseAsyncDataOptions<T>): UseAsyncDataReturn<T>;
+
+/**
+ * Hydrate data on client startup
+ */
+declare function hydrateFlightData(): void;
+
+export { type UseAsyncDataReturn, type UseFetchReturn, hydrateFlightData, useAsyncData, useFetch };

package/dist/solid.js

@@ -0,0 +1,142 @@
+import {
+  asyncData,
+  clearCache,
+  configureCache,
+  fetchData,
+  getCachedData,
+  hydrateFetchData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData
+} from "./chunk-NOWQL3EM.js";
+
+// src/solid.ts
+var Solid = null;
+function getSolid() {
+  if (Solid) return Solid;
+  const isBrowser = typeof window !== "undefined";
+  if (typeof globalThis !== "undefined") {
+    const g = globalThis;
+    if (g.Solid) {
+      Solid = g.Solid;
+    } else if (g.solidJs) {
+      Solid = g.solidJs;
+    }
+  }
+  if (!Solid && isBrowser) {
+    const w = window;
+    if (w.Solid) {
+      Solid = w.Solid;
+    }
+  }
+  if (!Solid) {
+    throw new Error(
+      "[@flightdev/data] Solid not found. Make sure Solid is available or import correctly."
+    );
+  }
+  return Solid;
+}
+function useFetch(url, options = {}) {
+  const { createSignal, createEffect, onMount, onCleanup } = getSolid();
+  const { immediate = true } = options;
+  const [data, setData] = createSignal(options.default);
+  const [pending, setPending] = createSignal(false);
+  const [error, setError] = createSignal(void 0);
+  const [status, setStatus] = createSignal("idle");
+  const [isStale, setIsStale] = createSignal(false);
+  const getUrl = () => {
+    return typeof url === "function" ? url() : url;
+  };
+  const execute = async () => {
+    const currentUrl = getUrl();
+    if (!currentUrl) return;
+    setPending(true);
+    const result = await fetchData(currentUrl, options);
+    setData(() => result.data);
+    setError(() => result.error);
+    setStatus(() => result.status);
+    setIsStale(() => result.isStale);
+    setPending(false);
+  };
+  const refresh = async () => {
+    const currentUrl = getUrl();
+    if (!currentUrl) return;
+    const key = options.key ?? currentUrl;
+    invalidate(key);
+    await execute();
+  };
+  if (typeof url === "function") {
+    createEffect(() => {
+      url();
+      if (immediate) execute();
+    });
+  }
+  onMount(() => {
+    if (immediate && getUrl()) {
+      execute();
+    }
+  });
+  if (options.revalidateOnFocus) {
+    const onFocus = () => execute();
+    onMount(() => window.addEventListener("focus", onFocus));
+    onCleanup(() => window.removeEventListener("focus", onFocus));
+  }
+  return {
+    data,
+    pending,
+    error,
+    status,
+    isStale,
+    refresh,
+    execute
+  };
+}
+function useAsyncData(key, fetcher, options = {}) {
+  const { createSignal, onMount } = getSolid();
+  const { immediate = true } = options;
+  const [data, setData] = createSignal(options.default);
+  const [pending, setPending] = createSignal(false);
+  const [error, setError] = createSignal(void 0);
+  const [status, setStatus] = createSignal("idle");
+  const execute = async () => {
+    setPending(true);
+    const result = await asyncData(key, fetcher, options);
+    setData(() => result.data);
+    setError(() => result.error);
+    setStatus(() => result.status);
+    setPending(false);
+  };
+  const refresh = async () => {
+    invalidate(key);
+    await execute();
+  };
+  onMount(() => {
+    if (immediate) {
+      execute();
+    }
+  });
+  return {
+    data,
+    pending,
+    error,
+    status,
+    execute,
+    refresh
+  };
+}
+function hydrateFlightData() {
+  hydrateFetchData();
+}
+export {
+  clearCache,
+  configureCache,
+  getCachedData,
+  hydrateFlightData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData,
+  useAsyncData,
+  useFetch
+};

package/dist/svelte.d.ts

@@ -0,0 +1,80 @@
+import { j as FetchState, U as UseFetchOptions, l as UseAsyncDataOptions } 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 - Svelte Adapter
+ *
+ * Svelte stores for data fetching using Flight's core.
+ * Uses Svelte stores: writable, derived.
+ *
+ * @module @flightdev/data/svelte
+ */
+
+interface Readable<T> {
+    subscribe: (run: (value: T) => void) => () => void;
+}
+interface UseFetchReturn<T> {
+    data: Readable<T | undefined>;
+    pending: Readable<boolean>;
+    error: Readable<Error | undefined>;
+    status: Readable<FetchState<T>['status']>;
+    isStale: Readable<boolean>;
+    refresh: () => Promise<void>;
+    execute: () => Promise<void>;
+}
+interface UseAsyncDataReturn<T> {
+    data: Readable<T | undefined>;
+    pending: Readable<boolean>;
+    error: Readable<Error | undefined>;
+    status: Readable<FetchState<T>['status']>;
+    execute: () => Promise<void>;
+    refresh: () => Promise<void>;
+}
+/**
+ * Svelte store for data fetching with caching and deduplication
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * import { useFetch } from '@flightdev/data/svelte';
+ *
+ * const { data, pending, error, refresh } = useFetch('/api/users');
+ * </script>
+ *
+ * {#if $pending}
+ *     <p>Loading...</p>
+ * {:else if $error}
+ *     <p>Error: {$error.message}</p>
+ * {:else}
+ *     <ul>
+ *         {#each $data as user}
+ *             <li>{user.name}</li>
+ *         {/each}
+ *     </ul>
+ * {/if}
+ * ```
+ */
+declare function useFetch<T = unknown>(url: string | null, options?: UseFetchOptions<T>): UseFetchReturn<T>;
+/**
+ * Svelte store for custom async data fetching
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * import { useAsyncData } from '@flightdev/data/svelte';
+ *
+ * const { data, pending, execute } = useAsyncData(
+ *     'analytics',
+ *     () => analyticsAPI.getReport()
+ * );
+ * </script>
+ * ```
+ */
+declare function useAsyncData<T = unknown>(key: string, fetcher: () => Promise<T>, options?: UseAsyncDataOptions<T>): UseAsyncDataReturn<T>;
+
+/**
+ * Hydrate data on client startup
+ */
+declare function hydrateFlightData(): void;
+
+export { type UseAsyncDataReturn, type UseFetchReturn, hydrateFlightData, useAsyncData, useFetch };

package/dist/svelte.js

@@ -0,0 +1,114 @@
+import {
+  asyncData,
+  clearCache,
+  configureCache,
+  fetchData,
+  getCachedData,
+  hydrateFetchData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData
+} from "./chunk-NOWQL3EM.js";
+
+// src/svelte.ts
+function createWritable(initial) {
+  let value = initial;
+  const subscribers = /* @__PURE__ */ new Set();
+  return {
+    subscribe(run) {
+      subscribers.add(run);
+      run(value);
+      return () => subscribers.delete(run);
+    },
+    set(newValue) {
+      value = newValue;
+      subscribers.forEach((fn) => fn(value));
+    },
+    update(fn) {
+      value = fn(value);
+      subscribers.forEach((fn2) => fn2(value));
+    }
+  };
+}
+function useFetch(url, options = {}) {
+  const { immediate = true } = options;
+  const data = createWritable(options.default);
+  const pending = createWritable(false);
+  const error = createWritable(void 0);
+  const status = createWritable("idle");
+  const isStale = createWritable(false);
+  const execute = async () => {
+    if (!url) return;
+    pending.set(true);
+    const result = await fetchData(url, options);
+    data.set(result.data);
+    error.set(result.error);
+    status.set(result.status);
+    isStale.set(result.isStale);
+    pending.set(false);
+  };
+  const refresh = async () => {
+    if (!url) return;
+    const key = options.key ?? url;
+    invalidate(key);
+    await execute();
+  };
+  if (immediate && url) {
+    execute();
+  }
+  return {
+    data,
+    pending,
+    error,
+    status,
+    isStale,
+    refresh,
+    execute
+  };
+}
+function useAsyncData(key, fetcher, options = {}) {
+  const { immediate = true } = options;
+  const data = createWritable(options.default);
+  const pending = createWritable(false);
+  const error = createWritable(void 0);
+  const status = createWritable("idle");
+  const execute = async () => {
+    pending.set(true);
+    const result = await asyncData(key, fetcher, options);
+    data.set(result.data);
+    error.set(result.error);
+    status.set(result.status);
+    pending.set(false);
+  };
+  const refresh = async () => {
+    invalidate(key);
+    await execute();
+  };
+  if (immediate) {
+    execute();
+  }
+  return {
+    data,
+    pending,
+    error,
+    status,
+    execute,
+    refresh
+  };
+}
+function hydrateFlightData() {
+  hydrateFetchData();
+}
+export {
+  clearCache,
+  configureCache,
+  getCachedData,
+  hydrateFlightData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData,
+  useAsyncData,
+  useFetch
+};

package/dist/vue.d.ts

@@ -0,0 +1,76 @@
+import { j as FetchState, U as UseFetchOptions, l as UseAsyncDataOptions } 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 - Vue Adapter
+ *
+ * Vue composables for data fetching using Flight's core.
+ * Uses Vue 3 Composition API: ref, watch, onMounted, onUnmounted.
+ *
+ * @module @flightdev/data/vue
+ */
+
+interface Ref<T> {
+    value: T;
+}
+interface UseFetchReturn<T> {
+    data: Ref<T | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | undefined>;
+    status: Ref<FetchState<T>['status']>;
+    isStale: Ref<boolean>;
+    refresh: () => Promise<void>;
+    execute: () => Promise<void>;
+}
+interface UseAsyncDataReturn<T> {
+    data: Ref<T | undefined>;
+    pending: Ref<boolean>;
+    error: Ref<Error | undefined>;
+    status: Ref<FetchState<T>['status']>;
+    execute: () => Promise<void>;
+    refresh: () => Promise<void>;
+}
+/**
+ * Vue composable for data fetching with caching and deduplication
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useFetch } from '@flightdev/data/vue';
+ *
+ * const { data, pending, error, refresh } = useFetch('/api/users');
+ * </script>
+ *
+ * <template>
+ *     <p v-if="pending">Loading...</p>
+ *     <p v-else-if="error">Error: {{ error.message }}</p>
+ *     <ul v-else>
+ *         <li v-for="user in data" :key="user.id">{{ user.name }}</li>
+ *     </ul>
+ * </template>
+ * ```
+ */
+declare function useFetch<T = unknown>(url: string | (() => string | null), options?: UseFetchOptions<T>): UseFetchReturn<T>;
+/**
+ * Vue composable for custom async data fetching
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useAsyncData } from '@flightdev/data/vue';
+ *
+ * const { data, pending, execute } = useAsyncData(
+ *     'analytics',
+ *     () => analyticsAPI.getReport()
+ * );
+ * </script>
+ * ```
+ */
+declare function useAsyncData<T = unknown>(key: string, fetcher: () => Promise<T>, options?: UseAsyncDataOptions<T>): UseAsyncDataReturn<T>;
+
+/**
+ * Hydrate data on client startup
+ */
+declare function hydrateFlightData(): void;
+
+export { type UseAsyncDataReturn, type UseFetchReturn, hydrateFlightData, useAsyncData, useFetch };

package/dist/vue.js

@@ -0,0 +1,136 @@
+import {
+  asyncData,
+  clearCache,
+  configureCache,
+  fetchData,
+  getCachedData,
+  hydrateFetchData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData
+} from "./chunk-NOWQL3EM.js";
+
+// src/vue.ts
+var Vue = null;
+function getVue() {
+  if (Vue) return Vue;
+  const isBrowser = typeof window !== "undefined";
+  if (typeof globalThis !== "undefined" && globalThis.Vue) {
+    Vue = globalThis.Vue;
+  }
+  if (!Vue && isBrowser) {
+    const w = window;
+    if (w.Vue) {
+      Vue = w.Vue;
+    }
+  }
+  if (!Vue) {
+    throw new Error(
+      "[@flightdev/data] Vue not found. Make sure Vue is available globally or import Vue composables correctly."
+    );
+  }
+  return Vue;
+}
+function useFetch(url, options = {}) {
+  const { ref, watch, onMounted, onUnmounted } = getVue();
+  const { immediate = true } = options;
+  const data = ref(options.default);
+  const pending = ref(false);
+  const error = ref(void 0);
+  const status = ref("idle");
+  const isStale = ref(false);
+  const getUrl = () => {
+    return typeof url === "function" ? url() : url;
+  };
+  const execute = async () => {
+    const currentUrl = getUrl();
+    if (!currentUrl) return;
+    pending.value = true;
+    const result = await fetchData(currentUrl, options);
+    data.value = result.data;
+    error.value = result.error;
+    status.value = result.status;
+    isStale.value = result.isStale;
+    pending.value = false;
+  };
+  const refresh = async () => {
+    const currentUrl = getUrl();
+    if (!currentUrl) return;
+    const key = options.key ?? currentUrl;
+    invalidate(key);
+    await execute();
+  };
+  if (typeof url === "function") {
+    watch(url, () => {
+      if (immediate) execute();
+    });
+  }
+  onMounted(() => {
+    if (immediate && getUrl()) {
+      execute();
+    }
+  });
+  if (options.revalidateOnFocus) {
+    const onFocus = () => execute();
+    onMounted(() => window.addEventListener("focus", onFocus));
+    onUnmounted(() => window.removeEventListener("focus", onFocus));
+  }
+  return {
+    data,
+    pending,
+    error,
+    status,
+    isStale,
+    refresh,
+    execute
+  };
+}
+function useAsyncData(key, fetcher, options = {}) {
+  const { ref, onMounted } = getVue();
+  const { immediate = true } = options;
+  const data = ref(options.default);
+  const pending = ref(false);
+  const error = ref(void 0);
+  const status = ref("idle");
+  const execute = async () => {
+    pending.value = true;
+    const result = await asyncData(key, fetcher, options);
+    data.value = result.data;
+    error.value = result.error;
+    status.value = result.status;
+    pending.value = false;
+  };
+  const refresh = async () => {
+    invalidate(key);
+    await execute();
+  };
+  onMounted(() => {
+    if (immediate) {
+      execute();
+    }
+  });
+  return {
+    data,
+    pending,
+    error,
+    status,
+    execute,
+    refresh
+  };
+}
+function hydrateFlightData() {
+  hydrateFetchData();
+}
+export {
+  clearCache,
+  configureCache,
+  getCachedData,
+  hydrateFlightData,
+  invalidate,
+  invalidateCache,
+  prefetch,
+  setCachedData,
+  useAsyncData,
+  useFetch
+};

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@flightdev/data",
+  "version": "0.0.6",
+  "description": "Data fetching primitives for Flight Framework - loaders, actions, forms, useFetch, and useAsyncData",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./vue": {
+      "types": "./dist/vue.d.ts",
+      "import": "./dist/vue.js"
+    },
+    "./svelte": {
+      "types": "./dist/svelte.d.ts",
+      "import": "./dist/svelte.js"
+    },
+    "./solid": {
+      "types": "./dist/solid.d.ts",
+      "import": "./dist/solid.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "flight",
+    "data",
+    "loader",
+    "action",
+    "forms",
+    "ssr",
+    "useFetch",
+    "useAsyncData",
+    "cache",
+    "react",
+    "vue",
+    "svelte",
+    "solid"
+  ],
+  "author": "Flight Framework",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EliosLT/Flight-framework",
+    "directory": "packages/data"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "vue": ">=3.0.0",
+    "svelte": ">=4.0.0",
+    "solid-js": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/react.ts src/vue.ts src/svelte.ts src/solid.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/react.ts src/vue.ts src/svelte.ts src/solid.ts --format esm --dts --watch"
+  }
+}