사용자 지정 Svelte 저장소를 비동기적으로 초기화

사용자 지정 Svelte 저장소를 비동기적으로 초기화

나는 스벨테와 타우리를 이용한 크로스 플랫폼 데스크톱 앱을 개발하려고 시도하고 있다 앱이 시작되면 settings.json-file을 파일 시스템에서 커스텀 스벨테 스토어에 로드해야 한다. 데이터에 쓰기 전에 사용자 정의 세트 기능을 사용하여 데이터를 검증해야 하므로 커스텀 스토어가 되어야 합니다. 스토어는 오브젝트를 보유할 것입니다.

나는 일반적인 Svelte를 사용하고 있고 SSR이 필요없어서 Svelte-kit을 사용하지 않는다.

문제

1. Tauri는 fs-api에서 파일을 읽기 위한 동기식 방법이 없다
2. 스벨테는 내가 이걸 하기 위해 찾을 수 있는 직관적인 방법이 없는 것 같다

테스트

• Svelte의 promiseStore 예제를 따라 일반 상점에서는 작동하지만 사용자 지정 설정 방법에 도달할 수 없으므로 사용자 지정 상점에서는 작동하지 않습니다
• 파일 읽기를 기다리는 재귀 타임아웃 함수 사용
• 파일 읽기 대기 중인 while-loop 사용
• Svelte가 초기화하기 전에 전역 변수에 데이터를 로드하는 방법을 찾으려고 시도했습니다

실패한 모든 시도를 게시한다면 많은 코드가 될 것이므로, 제가 이루고자 하는 것에 대한 예를 들어보겠습니다. settings-file을 읽는 것을 제외하고 createStore가 비동기 상태가 아닐 때 코드의 모든 것이 작동합니다.

import { writable, get as getStore } from 'svelte/store'; // Svelte store
import _set from 'lodash.set';                            // Creating objects with any key/path
import _merge from 'lodash.merge';                        // Merging objects
import { fs } from '@tauri-apps/api';                     // Accessing local filesystem


async function createStore() {
  // Read settings from the file system
  let settings = {}
  try { settings = JSON.parse(await fs.readTextFile('./settings.json')); }
  catch {}

  // Create the store
  const store = writable(settings);

  // Custom set function
  function set (key, value) {
    if(!key) return;

    // Use lodash to create an object
    const change = _set({}, key, value);

    // Retreive the current store and merge it with the object above
    const currentStore = getStore(store)
    const updated = _merge({}, currentStore, change)

    // Update the store
    store.update(() => updated)
    
    // Save the updated settings back to the filesystem
    fs.writeFile({
      contents: JSON.stringify(updated, null, 2),
      path: './settings.json'}
    )
  }

  // Bundle the custom store
  const customStore = {
    subscribe: store.subscribe,
    set
  }

  return customStore;
}

export default createStore();

---

비동기적으로 초기화해야 하는 사용자 정의 스토어가 있을 때, 스토어가 직접 필요한 경우 구성 요소에서 호출할 스토어에서 비동기 방식으로 이 작업을 수행합니다(약속을 반환하는 참고). 만약 오류가 발생했다면, 아직 처리되지 않았을 것입니다...)

앱.스벨트

<script>
    import settings from './settings'
    import {onMount} from 'svelte'
    
    let appInitialized

    onMount(async () => {
        try {
            await settings.init()           
            appInitialized = true
        }catch(error) {
            console.error(error)
        }
    })

</script>

{#if appInitialized}
    'showing App'
{:else}
    'initializing App'
{/if}

사용하여 초기화할 저장소가 하나뿐인 경우 대체 구성 요소 논리

<script>
    import settings from './settings'
</script>

{#await settings.init()}
    'initializing store'
{:then}
    'show App'
{:catch error}
    'Couldn't initialize - '{error.message}
{/await}

아니면 초기화할 상점이 더 많다면

<script>
    import settings from './settings'
    import store2 from './store2'
    import store3 from './store3'

    const initStores = [
        settings.init(),
        store2.init(),
        store3.init()
    ]
</script>

{#await Promise.all(initStores)}
    'initializing stores'
{:then}
    'showing App'
{:catch error}
    'Couldn't initialize - '{error.message}
{/await}

settings.js

import { writable, get } from 'svelte/store';
import { fs } from '@tauri-apps/api';  

function createStore() {

    let initialValue = {}
    // destructure the store on creation to have 'direct access' to methods
    const {subscribe, update, set} = writable(initialValue);

    return {
        subscribe,

        async init() {
            const savedSettings = JSON.parse(await fs.readTextFile('./settings.json'))
            set(savedSettings);
        },

        changeSetting(key, value) {
            if(!key) return;

            const storeValue = get(this)

            storeValue[key] = value

            update(_ => storeValue)
            
            fs.writeFile({
                contents: JSON.stringify(storeValue, null, 2),
                path: './settings.json'
            })
        }
    }
}

export default createStore();

---

: Corrl 수정된 답변에서 래퍼 구성 요소 접근 방식을 추천하지만 #if 대신 블록을 사용합니다.

---

설정 로드는 앱 시작의 일부이므로 설정 로드 후까지 스벨테 앱의 마운트를 지연시킬 수 있습니다.

이를 통해 구성요소는 적재 상태에 대한 걱정 없이 저장소를 사용할 수 있습니다:

// main.js
initSettings().then(()=> {
    new App({ target: document.body })
})

// settings.js
import { writable, get } from 'svelte/store';
import { fs } from '@tauri-apps/api';  

let store;
const settings = { 
  subscribe() {
    if (!store) {
      throw new Error('Not initialized')
    }
    return store.subscribe()
  },
  async changeSetting(key, value) {
    if (!store) {
      throw new Error('Not initialized')
    }
    // ... save to fs
  }
}

export default settings;

export async function initSettings() {
  const data = JSON.parse(await fs.readTextFile('./settings.json'))
  if (store) {
    store.set(data)
  } else {
    store = writable(data);
  }
}

단점은 그것이 앱의 시작을 지연시킨다는 것이고 만약 당신이 main.js에서 .catch를 구현하지 않는다면 그 약속이 거절되었을 때 그 앱은 빈 채로 있을 것이다.

---

@Corrl의 훌륭한 답변에서 영감을 얻었습니다. 여기에 2개의 스토어 생성 함수가 있다. asyncDerived는 전달된 약속을 해결하고 결과를 콜백 fn에 전달한다. lateInitLoadable은 init() 함수를 호출할 때만 초기화를 수행하므로 에서 수행해야 할 때처럼 lateinit을 수행할 수 있다.

다음은 실제 상점을 인스턴스화하는 예입니다:

export const websocketClient = lateInitLoadable(async () => {
    const client: MySpecialWebsocket = await setupWSOnlyAfterPageHasLoaded();
    return client;
});


export const highLevelClient = asyncDerived(
    [websocketClient.load],
    async ([$websocketClient]) => {
        const client = new HighLevelClient($websocketClient);
        await client.asyncSetup();
        return client;
    }
);

그러고 나서 스벨트에 반응해! 에서 꼭 전화하세요.

<script>
    import {onMount} from 'svelte'

    onMount(async () => {
        await websocketClient.init();
        await highLevelClient.load
        const val = await $highLevelClient.websocketRequest();
    })
</script>

{#await highLevelClient.load then $highLevelClient}
    'showing App'
{/await}

init를 스토어에 로컬라이제이션할 수 있는 방법은 다음과 같습니다:

import { browser } from '$app/environment';

if (browser) {
    websocketClient.init();
}

다음은 에 대한 출처입니다:

import { writable, type Readable } from 'svelte/store';

export type Loadable<T> = Readable<T> & { load: Promise<T>; init?: () => Promise<T> };

export function asyncDerived<S extends readonly unknown[], T>(
    deps: S,
    cb: (values: { [K in keyof S]: Awaited<S[K]> }) => Promise<T>
): Loadable<T> {
    const { subscribe, set } = writable<T>();
    const load = new Promise<T>((resolve) => {
        Promise.all(deps).then((resolvedDeps) => {
            cb(resolvedDeps).then((value) => {
                resolve(value);
                set(value);
            });
        });
    });

    return {
        subscribe,
        load
    };
}

export function lateInitLoadable<T>(lateInitFn: () => Promise<T>): Loadable<T> {
    const { subscribe, set } = writable<T>();
    // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
    let loadResolver: (value: T) => void = (_: T) => {};
    const load = new Promise<T>((resolve) => {
        loadResolver = resolve;
    });

    return {
        subscribe,
        async init() {
            const value = await lateInitFn();
            set(value as T);
            loadResolver(value as T);
            return value as T;
        },
        load
    };
}