svelte/store#writable JavaScript Examples

/** @param {any} value */
export function notifiable_store(value) {
	const store = writable(value);
	let ready = true;

	function notify() {
		ready = true;
		store.update((val) => val);
	}

	/** @param {any} new_value */
	function set(new_value) {
		ready = false;
		store.set(new_value);
	}

	/** @param {(value: any) => void} run */
	function subscribe(run) {
		/** @type {any} */
		let old_value;
		return store.subscribe((new_value) => {
			if (old_value === undefined || (ready && new_value !== old_value)) {
				run((old_value = new_value));
			}
		});
	}

	return { notify, set, subscribe };
}

_characterBalances = writable({
  // object containing balances for each type of fungible tokens  // @TODO: break it down ?
  coins: null,
  keys: null,
  fire: null,
  water: null,
  earth: null,
  air: null,
  electricity: null,
})

function routerStore(){

    const {subscribe} = writable(location.get(), set => {
        location.start(set);
        let un = aClickListener(location.go)
        return ()=>{
            location.stop();
            un();
        }
    });

    return {
        subscribe,
        goto: location.go,
        params: getParams, /* DEPRECATED */
        meta: meta, /* DEPRECATED */
        useHashNavigation: s => location.mode(s ? MODES.HASH : MODES.HISTORY), /* DEPRECATED */
        mode: {
            hash: ()=>location.mode(MODES.HASH),
            history: ()=>location.mode(MODES.HISTORY),
            memory: ()=>location.mode(MODES.MEMORY),
        },
        base: location.base,
        location: location.methods()
    }
}

writableFileStore = (key) => {
  let hasQueried = false;
  const store = writable(null, () => {
    const unsubscribe = store.subscribe((file) => {
      if (hasQueried) {
        set(key, file)
          .catch((err) => {
            console.warn(err);
          });
      }
    });
    return unsubscribe;
  });
  get(key)
    .then((value) => {
      hasQueried = true;
      if (value) {
        store.set(value);
      }
    });
  return store;
}

/**
 * Creates a basic reactive FSM. Based on XState
 * @param {Object} machine object representing the FSM
 * @returns {Writable<string>} active state
 */
export default function(machine) {
  const { subscribe, set, update } = writable(machine.initial);

  return {
    subscribe,
    send: (transition, cb=() => {}) => update((state) => {
      const nextState = machine
        .states[state]
        .on?.[transition];

      if (!nextState) return state;
      if (typeof cb === 'function') cb(nextState);

      return nextState;
    }),
    reset: () => set(machine.initial),
  };
}

logstore = writable({
  respHeader: {},
  response: '',
  headers: '',
  logid: '',
  title: '',
  path: '',
  url: '',
  ext: ''
})

export function createNotificationStore() {
  const _notification = writable({ id: undefined});
  let timeout;

  function send({ message, type = "default", code }) {
		_notification.set({ id: id(), type, message, code });
  }

  function clear() {
    _notification.set({ id: undefined });
  }

  const notifications = derived(_notification, ($notification, set) => {
    // if there already was a notification, let's clear the timer
    // and reset it here.
    clearTimeout(timeout);
    set($notification);
		// if this is not the reset message, set the timer.
    if ($notification.id) {
      timeout = setTimeout(clear, NOTIFICATION_TIMEOUT);
    }
  })
  const { subscribe } = notifications;

  return {
    timeoutID: timeout,
    subscribe,
    send,
    clear: () => {
      clearTimeout(timeout);
      clear();
    },
  }
}

export function create_updated_store() {
	const { set, subscribe } = writable(false);

	const interval = +(
		/** @type {string} */ (import.meta.env.VITE_SVELTEKIT_APP_VERSION_POLL_INTERVAL)
	);
	const initial = import.meta.env.VITE_SVELTEKIT_APP_VERSION;

	/** @type {NodeJS.Timeout} */
	let timeout;

	async function check() {
		if (import.meta.env.DEV || import.meta.env.SSR) return false;

		clearTimeout(timeout);

		if (interval) timeout = setTimeout(check, interval);

		const file = import.meta.env.VITE_SVELTEKIT_APP_VERSION_FILE;

		const res = await fetch(`${assets}/${file}`, {
			headers: {
				pragma: 'no-cache',
				'cache-control': 'no-cache'
			}
		});

		if (res.ok) {
			const { version } = await res.json();
			const updated = version !== initial;

			if (updated) {
				set(true);
				clearTimeout(timeout);
			}

			return updated;
		} else {
			throw new Error(`Version check failed: ${res.status}`);
		}
	}

	if (interval) timeout = setTimeout(check, interval);

	return {
		subscribe,
		check
	};
}

createLocalFilters() 
    {
        const { subscribe, update } = writable([])
        return {
            subscribe, update,
            add: (key, value) => update(store => {
                const filter = {key: key, value: value} 
                store = store.filter(item => { return item.key !== key && item.value.length > 0 })
                store.push(filter)
                return store
            }),
            remove: () => update(store => store = [])
        }
    }

_characterId = writable(null)

constructor({ name, icon, address }) {
    this.name = name;
    this.icon = icon;
    this.address = address;
    this.holdings = _.object(
      CONTRACTS.filter((x) => x.isERC20).map((x) => [x.name, writable(0)])
    );
  }

error = writable(null)

storedKeys = writable({})

export function getStore(id, initialValue) {
  return stores[id] || (stores[id] = writable(initialValue));
}

title = new writable('')

KonstaStore = writable({
  theme: 'material',
  dark: true,
  touchRipple: true,
})

location = writable({
  current: undefined,
  previous: undefined,
})