robonomics-interface-vue 0.2.1 → 0.2.2

package/dist/datalog/useDatalog.js

@@ -1,6 +1,7 @@
 import { tools } from "robonomics-interface";
 import { isRef, onUnmounted, ref, toRefs, watch } from "vue";
 import { useLoader } from "../tools/useLoader.js";
+import { usePolkadotApi } from "../usePolkadotApi.js";
 import { useQuery } from "./useQuery.js";
 /**
  * Vue сomposable for working with datalog
@@ -18,6 +19,7 @@ import { useQuery } from "./useQuery.js";
  */
 export function useDatalog(addressInit, { immediate = true } = {}) {
     const address = isRef(addressInit) ? addressInit : ref(addressInit);
+    const { isConnected, watchConnect } = usePolkadotApi();
     const { loader, setter, state } = useLoader();
     const { load, listen } = useQuery();
     const watcher = tools.createWatcher();
@@ -37,7 +39,14 @@ export function useDatalog(addressInit, { immediate = true } = {}) {
             watcher.set(unsubscribe);
         });
     };
-    watch(address, run, { immediate });
+    const isChangedArgs = ref(immediate);
+    watch(address, () => {
+        if (isChangedArgs.value || isConnected.value) {
+            run();
+        }
+        isChangedArgs.value = true;
+    }, { immediate });
+    watchConnect(run, { isCheck: isChangedArgs });
     onUnmounted(watcher.stop);
     return {
         ...toRefs(state),

package/dist/devices/____isWatch___useDevices copy.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from "vue";
+/**
+ * Vue сomposable for working with devices list
+ * @description Provides functionality for loading and tracking changes in devices list by address
+ * @param addressInit - Address for getting devices list
+ * @param options - Composable options
+ * @param [options.isWatch] - Whether to track changes in the address
+ * @param [options.immediate] - Whether to start loading immediately
+ * @returns Object with devices list state and management methods
+ * @example
+ * const { data, loading, error, load } = useDevices('5F...', { immediate: true })
+ *
+ * // With reactive address
+ * const address = ref('5F...')
+ * const { data } = useDevices(address)
+ */
+export declare function useDevices(addressInit: string | Ref<string>, { isWatch, immediate }?: {
+    isWatch?: boolean | undefined;
+    immediate?: boolean | undefined;
+}): {
+    load: () => void;
+    loading: Ref<boolean, boolean>;
+    error: Ref<Error | null, Error | null>;
+    data: Ref<string[] | null | undefined, string[] | null | undefined>;
+};

package/dist/devices/____isWatch___useDevices copy.js

@@ -0,0 +1,53 @@
+import { tools } from "robonomics-interface";
+import { isRef, onUnmounted, ref, toRefs, watch } from "vue";
+import { useLoader } from "../tools/useLoader.js";
+import { usePolkadotApi } from "../usePolkadotApi.js";
+import { useQuery } from "./useQuery.js";
+/**
+ * Vue сomposable for working with devices list
+ * @description Provides functionality for loading and tracking changes in devices list by address
+ * @param addressInit - Address for getting devices list
+ * @param options - Composable options
+ * @param [options.isWatch] - Whether to track changes in the address
+ * @param [options.immediate] - Whether to start loading immediately
+ * @returns Object with devices list state and management methods
+ * @example
+ * const { data, loading, error, load } = useDevices('5F...', { immediate: true })
+ *
+ * // With reactive address
+ * const address = ref('5F...')
+ * const { data } = useDevices(address)
+ */
+export function useDevices(addressInit, { isWatch = true, immediate = true } = {}) {
+    const address = isRef(addressInit) ? addressInit : ref(addressInit);
+    const { isConnected, watchConnect } = usePolkadotApi();
+    const { loader, setter, state } = useLoader();
+    const { getDevices } = useQuery();
+    const watcher = tools.createWatcher();
+    /**
+     * Loads devices list and subscribes to changes
+     * @description Stops previous subscription, loads devices list and subscribes to new changes
+     */
+    const load = () => {
+        loader(async () => {
+            watcher.stop();
+            const unsubscribe = await getDevices(address.value, setter);
+            watcher.set(unsubscribe);
+        });
+    };
+    if (isWatch) {
+        const isChangedArgs = ref(immediate);
+        watch(address, () => {
+            if (isChangedArgs.value || isConnected.value) {
+                load();
+            }
+            isChangedArgs.value = true;
+        }, { immediate });
+        watchConnect(load, { isCheck: isChangedArgs });
+    }
+    onUnmounted(watcher.stop);
+    return {
+        ...toRefs(state),
+        load
+    };
+}

package/dist/devices/useDevices.js

@@ -1,6 +1,7 @@
 import { tools } from "robonomics-interface";
 import { isRef, onUnmounted, ref, toRefs, watch } from "vue";
 import { useLoader } from "../tools/useLoader.js";
+import { usePolkadotApi } from "../usePolkadotApi.js";
 import { useQuery } from "./useQuery.js";
 /**
  * Vue сomposable for working with devices list
@@ -18,6 +19,7 @@ import { useQuery } from "./useQuery.js";
  */
 export function useDevices(addressInit, { immediate = true } = {}) {
     const address = isRef(addressInit) ? addressInit : ref(addressInit);
+    const { isConnected, watchConnect } = usePolkadotApi();
     const { loader, setter, state } = useLoader();
     const { getDevices } = useQuery();
     const watcher = tools.createWatcher();
@@ -32,7 +34,14 @@ export function useDevices(addressInit, { immediate = true } = {}) {
             watcher.set(unsubscribe);
         });
     };
-    watch(address, load, { immediate });
+    const isChangedArgs = ref(immediate);
+    watch(address, () => {
+        if (isChangedArgs.value || isConnected.value) {
+            load();
+        }
+        isChangedArgs.value = true;
+    }, { immediate });
+    watchConnect(load, { isCheck: isChangedArgs });
     onUnmounted(watcher.stop);
     return {
         ...toRefs(state),

package/dist/launch/useLaunch.js

@@ -1,6 +1,7 @@
 import { tools } from "robonomics-interface";
-import { onUnmounted, toRaw, toRefs, unref, watch } from "vue";
+import { onUnmounted, ref, toRaw, toRefs, unref, watch } from "vue";
 import { useLoader } from "../tools/useLoader.js";
+import { usePolkadotApi } from "../usePolkadotApi.js";
 import { useQuery } from "./useQuery.js";
 /**
  * Vue сomposable for working with launches
@@ -19,6 +20,7 @@ import { useQuery } from "./useQuery.js";
  * filter.value = { success: true, method: 'Launch', sender: '5F...' }
  */
 export function useLaunch(filter, { immediate = true } = {}) {
+    const { isConnected, watchConnect } = usePolkadotApi();
     const { loader, setter, state } = useLoader();
     const { listen } = useQuery();
     const watcher = tools.createWatcher();
@@ -38,7 +40,14 @@ export function useLaunch(filter, { immediate = true } = {}) {
             watcher.set(unsubscribe);
         });
     };
-    watch(() => filter, run, { immediate, deep: true });
+    const isChangedArgs = ref(immediate);
+    watch(() => filter, () => {
+        if (isChangedArgs.value || isConnected.value) {
+            run();
+        }
+        isChangedArgs.value = true;
+    }, { immediate, deep: true });
+    watchConnect(run, { isCheck: isChangedArgs });
     onUnmounted(watcher.stop);
     return {
         ...toRefs(state),

package/dist/subscription/useAvailableSubscriptions.js

@@ -1,6 +1,7 @@
 import { tools } from "robonomics-interface";
 import { onUnmounted, toRefs } from "vue";
 import { useLoader } from "../tools/useLoader.js";
+import { usePolkadotApi } from "../usePolkadotApi.js";
 import { useQuery } from "./useQuery.js";
 /**
  * Vue сomposable for working with available subscriptions
@@ -17,6 +18,7 @@ import { useQuery } from "./useQuery.js";
  * console.log('Available subscriptions:', data.value)
  */
 export function useAvailableSubscriptions({ immediate = true } = {}) {
+    const { isConnected, watchConnect } = usePolkadotApi();
     const { loader, setter, state } = useLoader();
     const { countAvailableSubscriptions } = useQuery();
     const watcher = tools.createWatcher();
@@ -32,7 +34,12 @@ export function useAvailableSubscriptions({ immediate = true } = {}) {
         });
     };
     if (immediate) {
-        load();
+        if (isConnected.value) {
+            load();
+        }
+        else {
+            watchConnect(load);
+        }
     }
     onUnmounted(watcher.stop);
     return {

package/dist/subscription/useSubscription.js

@@ -1,6 +1,7 @@
 import { tools } from "robonomics-interface";
 import { isRef, onUnmounted, ref, toRefs, watch } from "vue";
 import { useLoader } from "../tools/useLoader.js";
+import { usePolkadotApi } from "../usePolkadotApi.js";
 import { useQuery } from "./useQuery.js";
 /**
  * Vue сomposable for working with subscription
@@ -18,6 +19,7 @@ import { useQuery } from "./useQuery.js";
  */
 export function useSubscription(addressInit, { immediate = true } = {}) {
     const address = isRef(addressInit) ? addressInit : ref(addressInit);
+    const { isConnected, watchConnect } = usePolkadotApi();
     const { loader, setter, state } = useLoader();
     const { load } = useQuery();
     const watcher = tools.createWatcher();
@@ -34,7 +36,14 @@ export function useSubscription(addressInit, { immediate = true } = {}) {
             }
         });
     };
-    watch(address, run, { immediate });
+    const isChangedArgs = ref(immediate);
+    watch(address, () => {
+        if (isChangedArgs.value || isConnected.value) {
+            run();
+        }
+        isChangedArgs.value = true;
+    }, { immediate });
+    watchConnect(run, { isCheck: isChangedArgs });
     onUnmounted(watcher.stop);
     return {
         ...toRefs(state),

package/dist/tools/useLoader.d.ts

@@ -25,5 +25,5 @@ export declare function useLoader<T>(): {
         data: UnwrapRef<T> | null | undefined;
     };
     loader: (getter: () => void | Promise<void> | T | Promise<T>) => Promise<void>;
-    setter: (data: T, error?: null | Error) => void;
+    setter: (data: null | undefined | T, error?: null | Error) => void;
 };

package/dist/twin/useTwin.js

@@ -1,6 +1,7 @@
 import { tools } from "robonomics-interface";
 import { isRef, onUnmounted, ref, toRefs, watch } from "vue";
 import { useLoader } from "../tools/useLoader.js";
+import { usePolkadotApi } from "../usePolkadotApi.js";
 import { useQuery } from "./useQuery.js";
 /**
  * Vue сomposable for working with individual twin
@@ -18,6 +19,7 @@ import { useQuery } from "./useQuery.js";
  */
 export function useTwin(idInit, { immediate = true } = {}) {
     const id = isRef(idInit) ? idInit : ref(idInit);
+    const { isConnected, watchConnect } = usePolkadotApi();
     const { loader, setter, state } = useLoader();
     const { getTwin } = useQuery();
     const watcher = tools.createWatcher();
@@ -34,7 +36,14 @@ export function useTwin(idInit, { immediate = true } = {}) {
             }
         });
     };
-    watch(id, load, { immediate });
+    const isChangedArgs = ref(immediate);
+    watch(id, () => {
+        if (isChangedArgs.value || isConnected.value) {
+            load();
+        }
+        isChangedArgs.value = true;
+    }, { immediate });
+    watchConnect(load, { isCheck: isChangedArgs });
     onUnmounted(watcher.stop);
     return {
         ...toRefs(state),

package/dist/usePolkadotApi.d.ts

@@ -17,11 +17,14 @@ export declare const error: import("vue").Ref<any, any>;
  * })
  */
 export declare function usePolkadotApi(): {
-    instance: Instance | undefined;
+    instance: false | Instance | undefined;
     status: import("vue").Ref<any, any>;
     error: import("vue").Ref<any, any>;
     isDisconnected: import("vue").ComputedRef<boolean>;
     isConnected: import("vue").ComputedRef<boolean>;
     isConnecting: import("vue").ComputedRef<boolean>;
+    watchConnect: (fn: () => void, { isCheck }?: {
+        isCheck?: import("vue").Ref<boolean, boolean> | undefined;
+    }) => import("vue").WatchHandle;
     composeWithCheckConnection: <T extends (api: ApiPromise, ...args: Args) => ReturnType<T>, Args extends Parameters<T> extends [ApiPromise, ...infer R] ? R : never>(fn: T) => (...args: Args) => ReturnType<T>;
 };

package/dist/usePolkadotApi.js

@@ -1,5 +1,5 @@
 import { Instance } from "robonomics-interface";
-import { computed, inject, ref } from "vue";
+import { computed, hasInjectionContext, inject, ref, watch } from "vue";
 /** Polkadot network connection status */
 export const status = ref();
 /** Polkadot network connection error */
@@ -17,7 +17,10 @@ export const error = ref();
  * })
  */
 export function usePolkadotApi() {
-    const Polkadot = inject("Polkadot");
+    const Polkadot = hasInjectionContext() && inject("Polkadot");
+    if (!Polkadot) {
+        console.error(`Instance not found in context. Read https://vuejs.org/guide/reusability/composables.html to learn more`);
+    }
     /** Checks whether the client is disconnected */
     const isDisconnected = computed(() => status.value === Instance.STATUS.disconnected);
     /** Checks whether the client is connected */
@@ -34,11 +37,34 @@ export function usePolkadotApi() {
      * const result = await safeQuery() // Will throw an error if not connected
      */
     const composeWithCheckConnection = (fn) => (...args) => {
-        if (!isConnected.value || !Polkadot || !Polkadot.api) {
+        if (!isConnected.value) {
+            if (process.env.NODE_ENV !== "production") {
+                console.warn("Not connected", fn, args);
+            }
             throw new Error("Not connected");
         }
+        if (!Polkadot || !Polkadot.api) {
+            if (process.env.NODE_ENV !== "production") {
+                console.warn("Not found instance", fn, args, Polkadot);
+            }
+            throw new Error("Not found instance");
+        }
         return fn(Polkadot.api, ...args);
     };
+    /**
+     * Watch for the connection status of the API
+     * @description Watches for changes in connection status and calls the provided function when the API is connected
+     * @param fn - Function to call when the API is connected
+     * @param [options.isCheck] - Options object with an optional `isCheck` ref to control if the function should be called
+     * @returns A watch function
+     */
+    const watchConnect = (fn, { isCheck = ref(true) } = {}) => {
+        return watch(isConnected, () => {
+            if (isCheck.value && isConnected.value) {
+                fn();
+            }
+        }, { immediate: true });
+    };
     return {
         instance: Polkadot,
         status,
@@ -46,6 +72,7 @@ export function usePolkadotApi() {
         isDisconnected,
         isConnected,
         isConnecting,
+        watchConnect,
         composeWithCheckConnection
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robonomics-interface-vue",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "author": "vol4tim <sas@robonomics.network>",
   "license": "BSD-3-Clause",
   "type": "module",