@swoff/cli 0.4.3 → 0.4.4

package/templates/svelte/useSwoffAuth.js

@@ -0,0 +1,95 @@
+import { writable } from "svelte/store";
+import { onMount } from "svelte";
+import { getAuthState } from "../auth/state.js";
+import { setAuth, clearAuth, ensureValidAuth } from "../auth/store.js";
+
+export function useSwoffAuth() {
+  const authenticated = writable(false);
+  const auth = writable(null);
+  const online = writable(
+    typeof navigator !== "undefined" ? navigator.onLine : true,
+  );
+  const isLoading = writable(false);
+  const error = writable(null);
+
+  async function refreshState() {
+    try {
+      const authState = await getAuthState();
+      authenticated.set(authState.authenticated);
+      auth.set(authState.auth);
+      error.set(null);
+    } catch {
+      // ignore — auth not initialized
+    }
+  }
+
+  onMount(() => {
+    refreshState();
+
+    function onOnline() { online.set(true); }
+    function onOffline() { online.set(false); }
+    function onAuthChange() { refreshState(); }
+
+    window.addEventListener("online", onOnline);
+    window.addEventListener("offline", onOffline);
+    window.addEventListener("sw-auth-state-change", onAuthChange);
+
+    return () => {
+      window.removeEventListener("online", onOnline);
+      window.removeEventListener("offline", onOffline);
+      window.removeEventListener("sw-auth-state-change", onAuthChange);
+    };
+  });
+
+  async function doSetAuth(authData) {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      await setAuth(authData);
+      await refreshState();
+    } catch (err) {
+      error.set(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      isLoading.set(false);
+    }
+  }
+
+  async function doClearAuth() {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      await clearAuth();
+      await refreshState();
+    } catch (err) {
+      error.set(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      isLoading.set(false);
+    }
+  }
+
+  async function doEnsureValid() {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      const result = await ensureValidAuth();
+      await refreshState();
+      return result;
+    } catch (err) {
+      error.set(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    } finally {
+      isLoading.set(false);
+    }
+  }
+
+  return {
+    authenticated,
+    auth,
+    online,
+    isLoading,
+    error,
+    setAuth: doSetAuth,
+    clearAuth: doClearAuth,
+    ensureValid: doEnsureValid,
+  };
+}

package/templates/svelte/useSwoffAuth.ts

@@ -0,0 +1,96 @@
+import { writable } from "svelte/store";
+import { onMount } from "svelte";
+import { getAuthState } from "../auth/state";
+import { setAuth, clearAuth, ensureValidAuth } from "../auth/store";
+import type { AuthData } from "../auth/adapter";
+
+export function useSwoffAuth() {
+  const authenticated = writable(false);
+  const auth = writable<AuthData | null>(null);
+  const online = writable(
+    typeof navigator !== "undefined" ? navigator.onLine : true,
+  );
+  const isLoading = writable(false);
+  const error = writable<Error | null>(null);
+
+  async function refreshState() {
+    try {
+      const authState = await getAuthState();
+      authenticated.set(authState.authenticated);
+      auth.set(authState.auth);
+      error.set(null);
+    } catch {
+      // ignore — auth not initialized
+    }
+  }
+
+  onMount(() => {
+    refreshState();
+
+    function onOnline() { online.set(true); }
+    function onOffline() { online.set(false); }
+    function onAuthChange() { refreshState(); }
+
+    window.addEventListener("online", onOnline);
+    window.addEventListener("offline", onOffline);
+    window.addEventListener("sw-auth-state-change", onAuthChange);
+
+    return () => {
+      window.removeEventListener("online", onOnline);
+      window.removeEventListener("offline", onOffline);
+      window.removeEventListener("sw-auth-state-change", onAuthChange);
+    };
+  });
+
+  async function doSetAuth(authData: AuthData) {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      await setAuth(authData);
+      await refreshState();
+    } catch (err) {
+      error.set(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      isLoading.set(false);
+    }
+  }
+
+  async function doClearAuth() {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      await clearAuth();
+      await refreshState();
+    } catch (err) {
+      error.set(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      isLoading.set(false);
+    }
+  }
+
+  async function doEnsureValid(): Promise<AuthData | null> {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      const result = await ensureValidAuth();
+      await refreshState();
+      return result;
+    } catch (err) {
+      error.set(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    } finally {
+      isLoading.set(false);
+    }
+  }
+
+  return {
+    authenticated,
+    auth,
+    online,
+    isLoading,
+    error,
+    setAuth: doSetAuth,
+    clearAuth: doClearAuth,
+    ensureValid: doEnsureValid,
+  };
+}

package/templates/svelte/useSwoffFetch.js

@@ -0,0 +1,97 @@
+import { writable } from "svelte/store";
+import { onMount } from "svelte";
+import { fetchWithCache } from "../fetch/core.js";
+import { generateTags } from "../cache/tags.js";
+
+export function useSwoffFetch(url, options = {}) {
+  const {
+    select,
+    retry: retryOpt,
+    placeholderData,
+    onSuccess,
+    onError,
+    ...fetchOptions
+  } = options;
+
+  const data = writable(placeholderData ?? null);
+  const error = writable(null);
+  const loading = writable(url != null && options.enabled !== false);
+
+  const isEnabled = options.enabled !== false && url != null;
+  let refetchCount = 0;
+
+  function refetch() {
+    refetchCount++;
+    doFetch();
+  }
+
+  async function doFetch() {
+    if (!isEnabled) return;
+    const currentFetchId = refetchCount;
+
+    let retriesLeft =
+      retryOpt === true
+        ? Infinity
+        : typeof retryOpt === "number"
+          ? retryOpt
+          : 0;
+
+    loading.set(true);
+    try {
+      const { response } = await fetchWithCache(url, fetchOptions);
+      if (currentFetchId !== refetchCount) return;
+      if (response) {
+        if (!response.ok) {
+          let errorMessage = `HTTP ${response.status}`;
+          try {
+            const errBody = await response.json();
+            errorMessage = errBody?.message || errBody?.error || errorMessage;
+          } catch {}
+          throw new Error(errorMessage);
+        }
+        const raw = await response.json();
+        const selected = select ? select(raw) : raw;
+        data.set(selected);
+        error.set(null);
+        onSuccess?.(selected);
+      } else {
+        data.set(null);
+      }
+    } catch (err) {
+      if (currentFetchId !== refetchCount) return;
+      if (retriesLeft > 0) {
+        retriesLeft--;
+        await new Promise((r) => setTimeout(r, 1000));
+        return doFetch();
+      }
+      const e = err instanceof Error ? err : new Error(String(err));
+      error.set(e);
+      onError?.(e);
+    } finally {
+      if (currentFetchId === refetchCount) {
+        loading.set(false);
+      }
+    }
+  }
+
+  onMount(() => {
+    if (isEnabled) doFetch();
+
+    function onInvalidated(e) {
+      const detail = e.detail;
+      const tags = detail?.tags;
+      if (!tags || !Array.isArray(tags)) return;
+      const urlTags = generateTags(url);
+      if (tags.some((t) => urlTags.includes(t))) {
+        refetch();
+      }
+    }
+
+    window.addEventListener("cache-invalidated", onInvalidated);
+    return () => {
+      window.removeEventListener("cache-invalidated", onInvalidated);
+    };
+  });
+
+  return { data, error, loading, refetch };
+}

package/templates/svelte/useSwoffFetch.ts

@@ -0,0 +1,112 @@
+import { writable } from "svelte/store";
+import { onMount } from "svelte";
+import { fetchWithCache } from "../fetch/core";
+import { generateTags } from "../cache/tags";
+import type { FetchWithCacheOptions } from "../fetch/core";
+
+export function useSwoffFetch<T = unknown, R = T>(
+  url: string | null,
+  options: FetchWithCacheOptions & {
+    enabled?: boolean;
+    select?: (data: T) => R;
+    keepPreviousData?: boolean;
+    retry?: number | boolean;
+    placeholderData?: R;
+    onSuccess?: (data: R) => void;
+    onError?: (error: Error) => void;
+  } = {},
+) {
+  const {
+    select,
+    retry: retryOpt,
+    placeholderData,
+    onSuccess,
+    onError,
+    ...fetchOptions
+  } = options;
+
+  const data = writable<R | null>(placeholderData ?? null);
+  const error = writable<Error | null>(null);
+  const loading = writable(url != null && options.enabled !== false);
+
+  const isEnabled = options.enabled !== false && url != null;
+  let refetchCount = 0;
+
+  function refetch() {
+    refetchCount++;
+    doFetch();
+  }
+
+  let cancelled = false;
+
+  async function doFetch() {
+    if (!isEnabled) return;
+    const currentFetchId = refetchCount;
+
+    let retriesLeft: number =
+      retryOpt === true
+        ? Infinity
+        : typeof retryOpt === "number"
+          ? retryOpt
+          : 0;
+
+    loading.set(true);
+    try {
+      const { response } = await fetchWithCache(url, fetchOptions);
+      if (currentFetchId !== refetchCount) return;
+      if (response) {
+        if (!response.ok) {
+          let errorMessage = `HTTP ${response.status}`;
+          try {
+            const errBody = await response.json();
+            errorMessage = errBody?.message || errBody?.error || errorMessage;
+          } catch {}
+          throw new Error(errorMessage);
+        }
+        const raw: T = await response.json();
+        const selected = select ? select(raw) : (raw as unknown as R);
+        data.set(selected);
+        error.set(null);
+        onSuccess?.(selected);
+      } else {
+        data.set(null);
+      }
+    } catch (err) {
+      if (currentFetchId !== refetchCount) return;
+      if (retriesLeft > 0) {
+        retriesLeft--;
+        await new Promise((r) => setTimeout(r, 1000));
+        return doFetch();
+      }
+      const e = err instanceof Error ? err : new Error(String(err));
+      error.set(e);
+      onError?.(e);
+    } finally {
+      if (currentFetchId === refetchCount) {
+        loading.set(false);
+      }
+    }
+  }
+
+  onMount(() => {
+    if (isEnabled) doFetch();
+
+    function onInvalidated(e: Event) {
+      const detail = (e as CustomEvent).detail;
+      const tags = detail?.tags;
+      if (!tags || !Array.isArray(tags)) return;
+      const urlTags = generateTags(url!);
+      if (tags.some((t: string) => urlTags.includes(t))) {
+        refetch();
+      }
+    }
+
+    window.addEventListener("cache-invalidated", onInvalidated);
+    return () => {
+      cancelled = true;
+      window.removeEventListener("cache-invalidated", onInvalidated);
+    };
+  });
+
+  return { data, error, loading, refetch };
+}

package/templates/svelte/useSwoffMutation.js

@@ -0,0 +1,110 @@
+import { writable } from "svelte/store";
+import { fetchWithCache } from "../fetch/core.js";
+import {
+  trackMutation,
+  resolveMutation,
+  rejectMutation,
+} from "../mutation/state.js";
+
+export function useSwoffMutation(url, options = {}) {
+  const lastResult = writable(null);
+  const isLoading = writable(false);
+  const mutationId = writable(null);
+
+  const inFlightKeys = new Set();
+
+  async function mutate(body, callbacks) {
+    const key = options.mutationKey;
+    if (key && inFlightKeys.has(key)) return { status: "skipped" };
+    if (key) inFlightKeys.add(key);
+
+    let retriesLeft =
+      options.retry === true
+        ? Infinity
+        : typeof options.retry === "number"
+          ? options.retry
+          : 0;
+
+    const mid = "mut-" + crypto.randomUUID();
+    mutationId.set(mid);
+    trackMutation(mid, "pending");
+    isLoading.set(true);
+
+    options.onMutate?.();
+
+    const attempt = async () => {
+      try {
+        const {
+          mutationKey,
+          onMutate,
+          onSuccess,
+          onError,
+          onSettled,
+          retry,
+          ...fetchOnlyOptions
+        } = options;
+        const fetchOptions = { ...fetchOnlyOptions, body };
+        const { response, queued } = await fetchWithCache(url, fetchOptions);
+        if (queued) {
+          resolveMutation(mid, null);
+          isLoading.set(false);
+          const r = { status: "queued" };
+          lastResult.set(r);
+          options.onSettled?.();
+          callbacks?.onSettled?.();
+          if (key) inFlightKeys.delete(key);
+          return r;
+        }
+        const data = await response.json();
+        resolveMutation(mid, data);
+        isLoading.set(false);
+        const r = { status: "success", data };
+        lastResult.set(r);
+        options.onSuccess?.(data);
+        callbacks?.onSuccess?.(data);
+        options.onSettled?.();
+        callbacks?.onSettled?.();
+        if (key) inFlightKeys.delete(key);
+        return r;
+      } catch (err) {
+        if (retriesLeft > 0) {
+          retriesLeft--;
+          await new Promise((r) => setTimeout(r, 1000));
+          return attempt();
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        rejectMutation(mid, error);
+        isLoading.set(false);
+        const r = { status: "error", error };
+        lastResult.set(r);
+        options.onError?.(error);
+        callbacks?.onError?.(error);
+        options.onSettled?.();
+        callbacks?.onSettled?.();
+        if (key) inFlightKeys.delete(key);
+        return r;
+      }
+    };
+
+    return attempt();
+  }
+
+  function reset() {
+    lastResult.set(null);
+    isLoading.set(false);
+  }
+
+  return {
+    mutate,
+    isLoading,
+    isIdle: lastResult,
+    isQueued: lastResult,
+    isSuccess: lastResult,
+    isError: lastResult,
+    data: lastResult,
+    error: lastResult,
+    lastResult,
+    reset,
+    mutationId,
+  };
+}

package/templates/svelte/useSwoffMutation.ts

@@ -0,0 +1,141 @@
+import { writable } from "svelte/store";
+import { fetchWithCache } from "../fetch/core";
+import {
+  trackMutation,
+  resolveMutation,
+  rejectMutation,
+} from "../mutation/state";
+import type { FetchWithCacheOptions } from "../fetch/core";
+
+export interface MutateCallbacks<TData> {
+  onSuccess?: (data: TData) => void;
+  onError?: (error: Error) => void;
+  onSettled?: () => void;
+}
+
+export interface UseMutationOptions<TData> extends FetchWithCacheOptions {
+  onMutate?: () => void;
+  onSuccess?: (data: TData) => void;
+  onError?: (error: Error) => void;
+  onSettled?: () => void;
+  mutationKey?: string;
+  retry?: number | boolean;
+}
+
+export type MutateResult<T> =
+  | { status: "skipped" }
+  | { status: "queued" }
+  | { status: "success"; data: T }
+  | { status: "error"; error: Error };
+
+export function useSwoffMutation<TData = unknown>(
+  url: string,
+  options: UseMutationOptions<TData> = {},
+) {
+  const lastResult = writable<MutateResult<TData> | null>(null);
+  const isLoading = writable(false);
+  const mutationId = writable<string | null>(null);
+
+  const inFlightKeys = new Set<string>();
+
+  async function mutate(
+    body?: unknown,
+    callbacks?: MutateCallbacks<TData>,
+  ): Promise<MutateResult<TData>> {
+    const key = options.mutationKey;
+    if (key && inFlightKeys.has(key)) return { status: "skipped" };
+    if (key) inFlightKeys.add(key);
+
+    let retriesLeft: number =
+      options.retry === true
+        ? Infinity
+        : typeof options.retry === "number"
+          ? options.retry
+          : 0;
+
+    const mid = "mut-" + crypto.randomUUID();
+    mutationId.set(mid);
+    trackMutation(mid, "pending");
+    isLoading.set(true);
+
+    options.onMutate?.();
+
+    const attempt = async (): Promise<MutateResult<TData>> => {
+      try {
+        const {
+          mutationKey,
+          onMutate,
+          onSuccess,
+          onError,
+          onSettled,
+          retry,
+          ...fetchOnlyOptions
+        } = options;
+        const fetchOptions = { ...fetchOnlyOptions, body };
+        const { response, queued } = await fetchWithCache<TData>(
+          url,
+          fetchOptions as FetchWithCacheOptions,
+        );
+        if (queued) {
+          resolveMutation(mid, null);
+          isLoading.set(false);
+          const r: MutateResult<TData> = { status: "queued" };
+          lastResult.set(r);
+          options.onSettled?.();
+          callbacks?.onSettled?.();
+          if (key) inFlightKeys.delete(key);
+          return r;
+        }
+        const data: TData = await response.json();
+        resolveMutation(mid, data);
+        isLoading.set(false);
+        const r: MutateResult<TData> = { status: "success", data };
+        lastResult.set(r);
+        options.onSuccess?.(data);
+        callbacks?.onSuccess?.(data);
+        options.onSettled?.();
+        callbacks?.onSettled?.();
+        if (key) inFlightKeys.delete(key);
+        return r;
+      } catch (err) {
+        if (retriesLeft > 0) {
+          retriesLeft--;
+          await new Promise((r) => setTimeout(r, 1000));
+          return attempt();
+        }
+        const error = err instanceof Error ? err : new Error(String(err));
+        rejectMutation(mid, error);
+        isLoading.set(false);
+        const r: MutateResult<TData> = { status: "error", error };
+        lastResult.set(r);
+        options.onError?.(error);
+        callbacks?.onError?.(error);
+        options.onSettled?.();
+        callbacks?.onSettled?.();
+        if (key) inFlightKeys.delete(key);
+        return r;
+      }
+    };
+
+    return attempt();
+  }
+
+  function reset() {
+    lastResult.set(null);
+    isLoading.set(false);
+  }
+
+  return {
+    mutate,
+    isLoading,
+    isIdle: lastResult,
+    isQueued: lastResult,
+    isSuccess: lastResult,
+    isError: lastResult,
+    data: lastResult,
+    error: lastResult,
+    lastResult,
+    reset,
+    mutationId,
+  };
+}

package/templates/svelte/useSwoffMutationState.js

@@ -0,0 +1,27 @@
+import { writable } from "svelte/store";
+import { onMount } from "svelte";
+import { getMutationState, onMutationStateChange } from "../mutation/state.js";
+
+export function useSwoffMutationState(id) {
+  const state = writable(null);
+
+  function update() {
+    state.set(id ? (getMutationState(id) ?? null) : null);
+  }
+
+  onMount(update);
+
+  let cleanup;
+
+  onMount(() => {
+    const unsub = onMutationStateChange(update);
+    if (typeof unsub === "function") {
+      cleanup = unsub;
+    }
+    return () => {
+      cleanup?.();
+    };
+  });
+
+  return state;
+}

package/templates/svelte/useSwoffMutationState.ts

@@ -0,0 +1,28 @@
+import { writable } from "svelte/store";
+import { onMount } from "svelte";
+import { getMutationState, onMutationStateChange } from "../mutation/state";
+import type { MutationState } from "../mutation/state";
+
+export function useSwoffMutationState(id: string | null) {
+  const state = writable<MutationState | null>(null);
+
+  function update() {
+    state.set(id ? (getMutationState(id) ?? null) : null);
+  }
+
+  onMount(update);
+
+  let cleanup: (() => void) | undefined;
+
+  onMount(() => {
+    const unsub = onMutationStateChange(update);
+    if (typeof unsub === "function") {
+      cleanup = unsub;
+    }
+    return () => {
+      cleanup?.();
+    };
+  });
+
+  return state;
+}