resig.js/build/module/adapters/svelte4.js

Universal reactive signal library with complete platform features: signals, animations, CRDTs, scheduling, DOM integration. Works identically across React, SolidJS, Svelte, Vue, and Qwik.

/**
 * Svelte 4 Adapter for Signal-Σ - Uses traditional Svelte stores
 * Compatible with Svelte 4.x and earlier versions
 *
 * NOTE: This adapter is disabled because Svelte is not installed.
 * To enable, install Svelte and uncomment the code below.
 */
// Disabled - requires Svelte to be installed
export const SVELTE4_ADAPTER_DISABLED = true;
/*
// Note: Svelte 4 adapter requires Svelte to be installed
// import { writable, derived, readable } from 'svelte/store';
// import { onMount, onDestroy } from 'svelte';
import { fetch } from '../algebras/fetch';
import { machine } from '../algebras/state';
import { Effect, effect } from '../core/effect';
import { Signal, signal } from '../core/signal';

// Svelte 4 Signal adapter - uses writable stores
*/
// Placeholder exports to avoid module errors
export const useSignal = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const useComputed = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const useMachine = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const useFetch = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const useAsyncSignal = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const useAsyncResource = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const usePersistentSignal = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const useDebouncedSignal = () => {
    throw new Error('Svelte4 adapter is disabled');
};
export const useValidatedSignal = () => {
    throw new Error('Svelte4 adapter is disabled');
};
/*
// Original code commented out - requires Svelte to be installed
export function useSignal<T>(initialValue: T): [() => T, (value: T) => void] {
  const store = writable(initialValue);
  let currentValue = initialValue;
  
  // Subscribe to store changes to keep track of current value
  const unsubscribe = store.subscribe(value => {
    currentValue = value;
  });
  
  // Clean up subscription on component destroy
  onDestroy(() => {
    unsubscribe();
  });
  
  const getValue = () => currentValue;
  const setValue = (value: T) => {
    store.set(value);
  };
  
  return [getValue, setValue];
}

// Svelte 4 Computed adapter - uses derived stores
export function useComputed<T>(compute: () => T): () => T {
  let _currentValue = compute();
  
  // For now, return a simple function that computes the value
  // In a real implementation, this would track dependencies
  return () => compute();
}

// Svelte 4 Effect adapter
export function useEffect<T>(
  initialValue: T,
): [() => T, (value: T) => void, Effect<T>] {
  const store = writable(initialValue);
  const effectInstance = effect(initialValue);
  let currentValue = initialValue;
  
  // Subscribe to store changes
  const unsubscribe = store.subscribe(value => {
    currentValue = value;
    effectInstance._set(value);
  });
  
  // Clean up on destroy
  onDestroy(() => {
    unsubscribe();
  });
  
  const getValue = () => currentValue;
  const setValue = (value: T) => {
    store.set(value);
  };
  
  return [getValue, setValue, effectInstance];
}

// Svelte 4 State Machine adapter
export function useMachine<S, A>(
  initialState: S,
  reducer: (state: S, action: A) => S,
): [() => S, (action: A) => void] {
  const machineInstance = machine(initialState, reducer);
  const store = writable(machineInstance.state);
  let currentState = machineInstance.state;
  
  // Subscribe to machine state changes
  const machineUnsubscribe = machineInstance.subscribe((newState) => {
    currentState = newState;
    store.set(newState);
  });
  
  // Subscribe to store changes
  const storeUnsubscribe = store.subscribe(state => {
    currentState = state;
  });
  
  // Clean up on destroy
  onDestroy(() => {
    machineUnsubscribe();
    storeUnsubscribe();
  });
  
  const getState = () => currentState;
  const send = (action: A) => machineInstance.send(action);
  
  return [getState, send];
}

// Svelte 4 Fetch adapter
export function useFetch<T>(
  fetcher: () => Promise<T>,
): [() => { data?: T; loading: boolean; error?: Error }, () => void, (n: number) => void] {
  const fetchInstance = fetch(fetcher);
  const store = writable(fetchInstance.value());
  let currentState = fetchInstance.value();
  
  // Subscribe to fetch state changes
  const fetchUnsubscribe = fetchInstance.subscribe((newState) => {
    currentState = newState;
    store.set(newState);
  });
  
  // Subscribe to store changes
  const storeUnsubscribe = store.subscribe(state => {
    currentState = state;
  });
  
  // Clean up on destroy
  onDestroy(() => {
    fetchUnsubscribe();
    storeUnsubscribe();
  });
  
  const getState = () => currentState;
  
  const refetch = () => {
    const newFetch = fetch(fetcher);
    newFetch.subscribe((newState) => {
      currentState = newState;
      store.set(newState);
    });
    return newFetch;
  };
  
  const retry = (n: number) => {
    const retryFetch = fetchInstance.retry(n);
    retryFetch.subscribe((newState) => {
      currentState = newState;
      store.set(newState);
    });
    return retryFetch;
  };
  
  return [getState, refetch, retry];
}

// Svelte 4 Async Signal adapter
export function useAsyncSignal<T>(
  asyncFn: () => Promise<T>,
  initialValue?: T,
): [() => { data?: T; loading: boolean; error?: Error }, () => void, (value: T) => void] {
  const initialState = {
    data: initialValue,
    loading: false,
    error: undefined,
  };
  
  const store = writable<{ data?: T; loading: boolean; error?: Error }>(initialState);
  let currentState = initialState;
  
  // Subscribe to store changes
  const unsubscribe = store.subscribe(state => {
    currentState = state;
  });
  
  // Clean up on destroy
  onDestroy(() => {
    unsubscribe();
  });
  
  const getState = () => currentState;
  
  const refetch = async () => {
    store.update(state => ({ ...state, loading: true, error: undefined }));
    try {
      const data = await asyncFn();
      store.set({ data, loading: false, error: undefined });
    } catch (error) {
      store.update(state => ({
        ...state,
        loading: false,
        error: error instanceof Error ? error : new Error(String(error)),
      }));
    }
  };
  
  const setValue = (value: T) => {
    store.set({ data: value, loading: false, error: undefined });
  };
  
  return [getState, refetch, setValue];
}

// Svelte 4 Async Computed adapter
export function useAsyncComputed<T>(
  asyncCompute: () => Promise<T>,
  _deps: () => unknown[] = () => [],
): () => { data?: T; loading: boolean; error?: Error } {
  const initialState = {
    data: undefined,
    loading: false,
    error: undefined,
  };
  
  const store = writable<{ data?: T; loading: boolean; error?: Error }>(initialState);
  let currentState = initialState;
  
  // Subscribe to store changes
  const unsubscribe = store.subscribe(state => {
    currentState = state;
  });
  
  // Clean up on destroy
  onDestroy(() => {
    unsubscribe();
  });
  
  // Trigger computation on mount
  onMount(async () => {
    store.update(state => ({ ...state, loading: true, error: undefined }));
    
    try {
      const data = await asyncCompute();
      store.set({ data, loading: false, error: undefined });
    } catch (error) {
      store.update(state => ({
        ...state,
        loading: false,
        error: error instanceof Error ? error : new Error(String(error)),
      }));
    }
  });
  
  const getState = () => currentState;
  return getState;
}

// Svelte 4 Persistent Signal adapter
export function usePersistentSignal<T>(
  key: string,
  initialValue: T,
): [() => T, (value: T) => void] {
  // Try to load from localStorage
  let storedValue = initialValue;
  if (typeof window !== 'undefined') {
    try {
      const stored = localStorage.getItem(key);
      if (stored) {
        storedValue = JSON.parse(stored);
      }
    } catch (e) {
      // Use initial value if parsing fails
    }
  }
  
  const store = writable(storedValue);
  let currentValue = storedValue;
  
  // Subscribe to store changes and persist to localStorage
  const unsubscribe = store.subscribe(value => {
    currentValue = value;
    if (typeof window !== 'undefined') {
      try {
        localStorage.setItem(key, JSON.stringify(value));
      } catch (e) {
        // Ignore storage errors
      }
    }
  });
  
  // Clean up on destroy
  onDestroy(() => {
    unsubscribe();
  });
  
  const getValue = () => currentValue;
  const setValue = (value: T) => {
    store.set(value);
  };
  
  return [getValue, setValue];
}

// Svelte 4 Debounced Signal adapter
export function useDebouncedSignal<T>(
  initialValue: T,
  delay: number,
): [() => T, (value: T) => void, () => T] {
  const immediateStore = writable(initialValue);
  const debouncedStore = writable(initialValue);
  let immediateValue = initialValue;
  let debouncedValue = initialValue;
  let timeoutId: NodeJS.Timeout;

  // Subscribe to immediate store changes
  const immediateUnsubscribe = immediateStore.subscribe(value => {
    immediateValue = value;

    // Clear existing timeout
    clearTimeout(timeoutId);

    // Set new timeout for debounced value
    timeoutId = setTimeout(() => {
      debouncedStore.set(value);
    }, delay);
  });

  // Subscribe to debounced store changes
  const debouncedUnsubscribe = debouncedStore.subscribe(value => {
    debouncedValue = value;
  });

  // Clean up on destroy
  onDestroy(() => {
    clearTimeout(timeoutId);
    immediateUnsubscribe();
    debouncedUnsubscribe();
  });

  const getImmediate = () => immediateValue;
  const setImmediate = (value: T) => {
    immediateStore.set(value);
  };
  const getDebounced = () => debouncedValue;

  return [getImmediate, setImmediate, getDebounced];
}

// Svelte 4 Validated Signal adapter
export function useValidatedSignal<T>(
  initialValue: T,
  validator: (value: T) => boolean,
): [() => T, (value: T) => void, () => boolean] {
  const store = writable(initialValue);
  let currentValue = initialValue;
  let isValid = validator(initialValue);

  // Subscribe to store changes
  const unsubscribe = store.subscribe(value => {
    currentValue = value;
    isValid = validator(value);
  });

  // Clean up on destroy
  onDestroy(() => {
    unsubscribe();
  });

  const getValue = () => currentValue;
  const setValue = (value: T) => {
    store.set(value);
  };
  const getIsValid = () => isValid;

  return [getValue, setValue, getIsValid];
}
*/
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ZlbHRlNC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hZGFwdGVycy9zdmVsdGU0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILDZDQUE2QztBQUM3QyxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRyxJQUFJLENBQUM7QUFFN0M7Ozs7Ozs7Ozs7RUFVRTtBQUVGLDZDQUE2QztBQUM3QyxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsR0FBRyxFQUFFO0lBQzVCLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLENBQUMsQ0FBQztBQUNqRCxDQUFDLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsR0FBRyxFQUFFO0lBQzlCLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLENBQUMsQ0FBQztBQUNqRCxDQUFDLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsR0FBRyxFQUFFO0lBQzdCLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLENBQUMsQ0FBQztBQUNqRCxDQUFDLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxRQUFRLEdBQUcsR0FBRyxFQUFFO0lBQzNCLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLENBQUMsQ0FBQztBQUNqRCxDQUFDLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsR0FBRyxFQUFFO0lBQ2pDLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLENBQUMsQ0FBQztBQUNqRCxDQUFDLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxHQUFHLEVBQUU7SUFDbkMsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO0FBQ2pELENBQUMsQ0FBQztBQUNGLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLEdBQUcsRUFBRTtJQUN0QyxNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUM7QUFDakQsQ0FBQyxDQUFDO0FBQ0YsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsR0FBRyxFQUFFO0lBQ3JDLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLENBQUMsQ0FBQztBQUNqRCxDQUFDLENBQUM7QUFDRixNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxHQUFHLEVBQUU7SUFDckMsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO0FBQ2pELENBQUMsQ0FBQztBQUVGOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztFQThWRSJ9