@djvlc/runtime-host-vue 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/vue-runtime.ts
-import { ref, shallowRef, readonly } from "vue";
+import { ref, shallowRef, readonly, computed } from "vue";
 import {
   createRuntime
 } from "@djvlc/runtime-core";
@@ -10,11 +10,33 @@ function createVueRuntime(options) {
   const page = shallowRef(null);
   const error = shallowRef(null);
   const hostApi = shallowRef(null);
+  const isReady = computed(() => phase.value === "ready");
+  const hasError = computed(() => phase.value === "error" || error.value !== null);
+  const metrics = shallowRef({
+    initTime: 0,
+    loadTime: 0,
+    renderTime: 0,
+    totalTime: 0,
+    initTimestamp: null,
+    readyTimestamp: null
+  });
+  let startTime = 0;
+  let initStartTime = 0;
+  let loadStartTime = 0;
+  let renderStartTime = 0;
   const init = async () => {
     const container = options.containerRef?.value;
     if (!container) {
       throw new Error("Container element not found");
     }
+    startTime = performance.now();
+    initStartTime = startTime;
+    if (options.enableMetrics) {
+      metrics.value = {
+        ...metrics.value,
+        initTimestamp: Date.now()
+      };
+    }
     const runtimeInstance = createRuntime({
       ...options,
       container,
@@ -39,22 +61,45 @@ function createVueRuntime(options) {
     });
     await runtimeInstance.init();
     hostApi.value = runtimeInstance.getHostApi();
+    if (options.enableMetrics) {
+      metrics.value = {
+        ...metrics.value,
+        initTime: performance.now() - initStartTime
+      };
+    }
   };
   const load = async () => {
     if (!runtime.value) {
       throw new Error("Runtime not initialized");
     }
+    loadStartTime = performance.now();
     const result = await runtime.value.load();
     page.value = result;
     hostApi.value = runtime.value.getHostApi();
+    if (options.enableMetrics) {
+      metrics.value = {
+        ...metrics.value,
+        loadTime: performance.now() - loadStartTime
+      };
+    }
     return result;
   };
   const render = async () => {
     if (!runtime.value) {
       throw new Error("Runtime not initialized");
     }
+    renderStartTime = performance.now();
     await runtime.value.render();
     loading.value = false;
+    if (options.enableMetrics) {
+      const now = performance.now();
+      metrics.value = {
+        ...metrics.value,
+        renderTime: now - renderStartTime,
+        totalTime: now - startTime,
+        readyTimestamp: Date.now()
+      };
+    }
   };
   const destroy = () => {
     runtime.value?.destroy();
@@ -65,12 +110,41 @@ function createVueRuntime(options) {
     phase.value = "idle";
     loading.value = true;
   };
+  const reload = async () => {
+    if (!runtime.value) {
+      throw new Error("Runtime not initialized");
+    }
+    error.value = null;
+    loading.value = true;
+    await load();
+    await render();
+  };
   const setVariable = (key, value) => {
     runtime.value?.setVariable(key, value);
   };
+  const setVariables = (variables) => {
+    if (!runtime.value) return;
+    Object.entries(variables).forEach(([key, value]) => {
+      runtime.value?.setVariable(key, value);
+    });
+  };
+  const getVariable = (key) => {
+    return runtime.value?.getState().variables[key];
+  };
   const refreshData = async (queryId) => {
     await runtime.value?.refreshData(queryId);
   };
+  const executeAction = async (actionType, params) => {
+    const api = hostApi.value;
+    if (!api) {
+      throw new Error("HostAPI not available");
+    }
+    const response = await api.executeAction(actionType, params || {});
+    if (response.success) {
+      return response.data;
+    }
+    throw new Error(response.errorMessage || "Action failed");
+  };
   return {
     runtime,
     loading: readonly(loading),
@@ -78,12 +152,19 @@ function createVueRuntime(options) {
     page,
     error,
     hostApi,
+    isReady,
+    hasError,
+    metrics,
     init,
     load,
     render,
     destroy,
+    reload,
     setVariable,
-    refreshData
+    setVariables,
+    getVariable,
+    refreshData,
+    executeAction
   };
 }
 
@@ -91,15 +172,25 @@ function createVueRuntime(options) {
 import {
   defineComponent,
   ref as ref3,
-  shallowRef as shallowRef2,
-  onMounted,
+  shallowRef as shallowRef3,
+  onMounted as onMounted2,
   onUnmounted as onUnmounted2,
-  watch,
+  watch as watch2,
   h
 } from "vue";
 
 // src/composables/useRuntime.ts
-import { inject, provide, ref as ref2, computed, onUnmounted } from "vue";
+import {
+  inject,
+  provide,
+  readonly as readonly2,
+  ref as ref2,
+  shallowRef as shallowRef2,
+  computed as computed2,
+  watch,
+  onMounted,
+  onUnmounted
+} from "vue";
 var RuntimeContextKey = /* @__PURE__ */ Symbol("DJVRuntime");
 function provideRuntime(value) {
   provide(RuntimeContextKey, value);
@@ -113,16 +204,30 @@ function injectRuntime() {
 }
 function useDJVRuntime() {
   const context = injectRuntime();
+  const loading = computed2(() => {
+    const phase = context.value.state.phase;
+    return phase !== "ready" && phase !== "error";
+  });
+  const isReady = computed2(() => context.value.state.phase === "ready");
+  const hasError = computed2(() => context.value.state.phase === "error" || context.value.state.error !== null);
+  const reload = async () => {
+    const runtime = context.value.runtime;
+    if (!runtime) {
+      throw new Error("Runtime not available");
+    }
+    await runtime.load();
+    await runtime.render();
+  };
   return {
-    runtime: computed(() => context.value.runtime),
-    state: computed(() => context.value.state),
-    loading: computed(() => {
-      const phase = context.value.state.phase;
-      return phase !== "ready" && phase !== "error";
-    }),
-    phase: computed(() => context.value.state.phase),
-    error: computed(() => context.value.state.error),
-    page: computed(() => context.value.state.page)
+    runtime: computed2(() => context.value.runtime),
+    state: computed2(() => context.value.state),
+    loading,
+    phase: computed2(() => context.value.state.phase),
+    error: computed2(() => context.value.state.error),
+    page: computed2(() => context.value.state.page),
+    isReady,
+    hasError,
+    reload
   };
 }
 function useHostApi() {
@@ -135,13 +240,13 @@ function useHostApi() {
 }
 function useRuntimeState(key) {
   const context = injectRuntime();
-  return computed(() => {
+  return computed2(() => {
     return context.value.state.variables[key];
   });
 }
 function useRuntimeStateWritable(key, defaultValue) {
   const context = injectRuntime();
-  const value = computed(() => {
+  const value = computed2(() => {
     return context.value.state.variables[key] ?? defaultValue;
   });
   const setValue = (newValue) => {
@@ -149,11 +254,13 @@ function useRuntimeStateWritable(key, defaultValue) {
   };
   return [value, setValue];
 }
-function useQuery(queryId) {
+function useQuery(queryId, options) {
   const context = injectRuntime();
   const loading = ref2(false);
   const error = ref2(null);
-  const data = computed(() => {
+  const lastUpdated = ref2(null);
+  let intervalTimer = null;
+  const data = computed2(() => {
     return context.value.state.queries[queryId];
   });
   const refetch = async () => {
@@ -161,41 +268,84 @@ function useQuery(queryId) {
     error.value = null;
     try {
       await context.value.runtime?.refreshData(queryId);
+      lastUpdated.value = Date.now();
     } catch (e) {
       error.value = e;
     } finally {
       loading.value = false;
     }
   };
+  onMounted(() => {
+    if (options?.refreshOnMount && context.value.runtime) {
+      refetch();
+    }
+    if (options?.refreshInterval && options.refreshInterval > 0) {
+      intervalTimer = setInterval(refetch, options.refreshInterval);
+    }
+    if (options?.refreshOnFocus) {
+      window.addEventListener("focus", refetch);
+    }
+  });
+  onUnmounted(() => {
+    if (intervalTimer) {
+      clearInterval(intervalTimer);
+    }
+    if (options?.refreshOnFocus) {
+      window.removeEventListener("focus", refetch);
+    }
+  });
   return {
     data,
     loading,
     error,
-    refetch
+    refetch,
+    lastUpdated
   };
 }
-function useAction(actionType) {
+function useAction(actionType, options) {
   const context = injectRuntime();
   const loading = ref2(false);
-  const result = ref2();
+  const result = shallowRef2();
   const error = ref2(null);
-  const execute = async (params) => {
+  const executionCount = ref2(0);
+  const reset = () => {
+    result.value = void 0;
+    error.value = null;
+    executionCount.value = 0;
+  };
+  const executeWithRetry = async (params, retriesLeft) => {
     const hostApi = context.value.hostApi;
     if (!hostApi) {
       throw new Error("HostAPI not available");
     }
-    loading.value = true;
-    error.value = null;
     try {
       const response = await hostApi.executeAction(actionType, params);
       if (response.success) {
-        result.value = response.data;
         return response.data;
       } else {
-        throw new Error(response.message || "Action failed");
+        throw new Error(response.errorMessage || "Action failed");
       }
     } catch (e) {
-      error.value = e;
+      if (retriesLeft > 0) {
+        await new Promise((resolve) => setTimeout(resolve, options?.retryDelay || 1e3));
+        return executeWithRetry(params, retriesLeft - 1);
+      }
+      throw e;
+    }
+  };
+  const execute = async (params) => {
+    loading.value = true;
+    error.value = null;
+    executionCount.value++;
+    try {
+      const data = await executeWithRetry(params, options?.retryCount || 0);
+      result.value = data;
+      options?.onSuccess?.(data);
+      return data;
+    } catch (e) {
+      const err = e;
+      error.value = err;
+      options?.onError?.(err);
       throw e;
     } finally {
       loading.value = false;
@@ -205,14 +355,25 @@ function useAction(actionType) {
     execute,
     loading,
     result,
-    error
+    error,
+    reset,
+    executionCount
   };
 }
 function useData(queryId, params, options) {
   const context = injectRuntime();
-  const data = ref2();
+  const data = shallowRef2();
   const loading = ref2(false);
   const error = ref2(null);
+  const isFetched = ref2(false);
+  let intervalTimer = null;
+  const getCurrentParams = () => {
+    if (!params) return void 0;
+    if (typeof params === "object" && "value" in params) {
+      return params.value;
+    }
+    return params;
+  };
   const refetch = async (newParams) => {
     const hostApi = context.value.hostApi;
     if (!hostApi) {
@@ -221,29 +382,47 @@ function useData(queryId, params, options) {
     loading.value = true;
     error.value = null;
     try {
-      const response = await hostApi.requestData(
+      const result = await hostApi.requestData(
         queryId,
-        newParams || params
+        newParams || getCurrentParams()
       );
-      if (response.success) {
-        data.value = response.data;
-      } else {
-        throw new Error(response.message || "Query failed");
-      }
+      data.value = result;
+      isFetched.value = true;
+      options?.onSuccess?.(result);
     } catch (e) {
-      error.value = e;
+      const err = e;
+      error.value = err;
+      options?.onError?.(err);
     } finally {
       loading.value = false;
     }
   };
-  if (options?.immediate !== false) {
-    refetch();
+  if (params && typeof params === "object" && "value" in params && options?.refreshOnParamsChange !== false) {
+    watch(params, () => {
+      if (isFetched.value) {
+        refetch();
+      }
+    }, { deep: true });
   }
+  onMounted(() => {
+    if (options?.immediate !== false && context.value.hostApi) {
+      refetch();
+    }
+    if (options?.refreshInterval && options.refreshInterval > 0) {
+      intervalTimer = setInterval(refetch, options.refreshInterval);
+    }
+  });
+  onUnmounted(() => {
+    if (intervalTimer) {
+      clearInterval(intervalTimer);
+    }
+  });
   return {
     data,
     loading,
     error,
-    refetch
+    refetch,
+    isFetched
   };
 }
 function useRuntimeEvent(eventType, handler) {
@@ -255,6 +434,145 @@ function useRuntimeEvent(eventType, handler) {
     unsubscribe?.();
   });
 }
+function usePageInfo() {
+  const context = injectRuntime();
+  return {
+    /** 页面 UID */
+    pageUid: computed2(() => context.value.state.page?.pageUid),
+    /** 页面版本 ID */
+    pageVersionId: computed2(() => context.value.state.page?.pageVersionId),
+    /** Schema 版本 */
+    schemaVersion: computed2(() => context.value.state.page?.pageJson?.schemaVersion),
+    /** 页面标题 */
+    title: computed2(() => {
+      const page = context.value.state.page;
+      return page?.title;
+    }),
+    /** 页面配置 */
+    config: computed2(() => {
+      const page = context.value.state.page;
+      return page?.config;
+    }),
+    /** 页面是否已加载 */
+    isLoaded: computed2(() => context.value.state.page !== null)
+  };
+}
+function useComponentState(componentId) {
+  const context = injectRuntime();
+  const componentStatus = computed2(() => {
+    return context.value.state.components.get(componentId);
+  });
+  return {
+    /** 组件是否已加载 */
+    isLoaded: computed2(() => componentStatus.value?.status === "loaded"),
+    /** 组件是否加载中 */
+    isLoading: computed2(() => componentStatus.value?.status === "loading"),
+    /** 组件是否加载失败 */
+    hasError: computed2(() => componentStatus.value?.status === "failed"),
+    /** 加载耗时 */
+    loadTime: computed2(() => componentStatus.value?.loadTime),
+    /** 组件信息 */
+    info: componentStatus
+  };
+}
+function useLifecycle(options) {
+  const context = injectRuntime();
+  const hasMounted = ref2(false);
+  const hasReady = ref2(false);
+  watch(
+    () => context.value.state.phase,
+    async (newPhase, oldPhase) => {
+      options?.onPhaseChange?.(newPhase);
+      if (!hasMounted.value && newPhase !== "idle") {
+        hasMounted.value = true;
+        try {
+          await options?.onMounted?.();
+        } catch (error) {
+          options?.onError?.(error);
+        }
+      }
+      if (!hasReady.value && newPhase === "ready") {
+        hasReady.value = true;
+        try {
+          await options?.onReady?.();
+        } catch (error) {
+          options?.onError?.(error);
+        }
+      }
+      if (newPhase === "error" && oldPhase !== "error") {
+        options?.onError?.(context.value.state.error);
+      }
+    },
+    { immediate: true }
+  );
+  return {
+    /** 当前阶段 */
+    phase: computed2(() => context.value.state.phase),
+    /** 是否已 mounted */
+    hasMounted: readonly2(hasMounted),
+    /** 是否已 ready */
+    hasReady: readonly2(hasReady)
+  };
+}
+function useWhen(condition, callback, options) {
+  const executed = ref2(false);
+  const { once = true, immediate = true } = options || {};
+  const stop = watch(
+    condition,
+    async (value) => {
+      if (value && (!once || !executed.value)) {
+        executed.value = true;
+        await callback();
+        if (once) {
+          stop();
+        }
+      }
+    },
+    { immediate }
+  );
+  onUnmounted(() => {
+    stop();
+  });
+  return {
+    /** 是否已执行 */
+    executed: readonly2(executed),
+    /** 手动停止监听 */
+    stop
+  };
+}
+function useDebouncedAction(actionType, delay = 300) {
+  const { execute: rawExecute, loading, result, error } = useAction(actionType);
+  let timeoutId = null;
+  const execute = (params) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      rawExecute(params).catch(() => {
+      });
+    }, delay);
+  };
+  const cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  onUnmounted(() => {
+    cancel();
+  });
+  return {
+    execute,
+    loading,
+    result,
+    error,
+    cancel
+  };
+}
+function useGlobalConfig() {
+  const config = inject("djvlc-config", {});
+  return config;
+}
 
 // src/components/DJVRenderer.ts
 var DJVRenderer = defineComponent({
@@ -287,12 +605,27 @@ var DJVRenderer = defineComponent({
     enableSRI: {
       type: Boolean,
       default: true
+    },
+    retryCount: {
+      type: Number,
+      default: 3
+    },
+    retryDelay: {
+      type: Number,
+      default: 1e3
+    },
+    timeout: {
+      type: Number,
+      default: 3e4
     }
   },
-  emits: ["load", "error", "ready"],
+  emits: ["load", "error", "ready", "phase-change"],
   setup(props, { emit, slots }) {
     const containerRef = ref3(null);
-    const contextValue = shallowRef2({
+    const mounted = ref3(true);
+    const retryAttempt = ref3(0);
+    const phase = ref3("idle");
+    const contextValue = shallowRef3({
       runtime: null,
       state: {
         phase: "idle",
@@ -307,8 +640,16 @@ var DJVRenderer = defineComponent({
     });
     provideRuntime(contextValue);
     let vueRuntime = null;
-    const initAndLoad = async () => {
-      if (!containerRef.value) return;
+    const withTimeout = (promise, ms) => {
+      return Promise.race([
+        promise,
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("\u52A0\u8F7D\u8D85\u65F6")), ms)
+        )
+      ]);
+    };
+    const initWithRetry = async () => {
+      if (!containerRef.value || !mounted.value) return;
       const options = {
         pageUid: props.pageUid,
         apiBaseUrl: props.apiBaseUrl,
@@ -327,56 +668,126 @@ var DJVRenderer = defineComponent({
       };
       vueRuntime = createVueRuntime(options);
       try {
-        await vueRuntime.init();
-        contextValue.value = {
-          runtime: vueRuntime.runtime.value,
-          state: vueRuntime.runtime.value?.getState() || contextValue.value.state,
-          hostApi: vueRuntime.hostApi.value
-        };
-        const page = await vueRuntime.load();
-        emit("load", page);
-        contextValue.value = {
-          ...contextValue.value,
-          state: vueRuntime.runtime.value?.getState() || contextValue.value.state,
-          hostApi: vueRuntime.hostApi.value
-        };
-        await vueRuntime.render();
-        emit("ready");
-        vueRuntime.runtime.value?.onStateChange((state) => {
-          contextValue.value = {
-            ...contextValue.value,
-            state
-          };
-        });
+        await withTimeout(
+          (async () => {
+            await vueRuntime.init();
+            if (!mounted.value) return;
+            phase.value = "loading";
+            emit("phase-change", "loading");
+            contextValue.value = {
+              runtime: vueRuntime.runtime.value,
+              state: vueRuntime.runtime.value?.getState() || contextValue.value.state,
+              hostApi: vueRuntime.hostApi.value
+            };
+            const pageData = await vueRuntime.load();
+            if (!mounted.value) return;
+            emit("load", pageData);
+            contextValue.value = {
+              ...contextValue.value,
+              state: vueRuntime.runtime.value?.getState() || contextValue.value.state,
+              hostApi: vueRuntime.hostApi.value
+            };
+            await vueRuntime.render();
+            if (!mounted.value) return;
+            phase.value = "ready";
+            emit("phase-change", "ready");
+            emit("ready");
+            retryAttempt.value = 0;
+            vueRuntime.runtime.value?.onStateChange((state) => {
+              if (!mounted.value) return;
+              contextValue.value = {
+                ...contextValue.value,
+                state
+              };
+              phase.value = state.phase;
+              emit("phase-change", state.phase);
+            });
+          })(),
+          props.timeout
+        );
       } catch (error) {
-        emit("error", error);
+        if (!mounted.value) return;
+        if (retryAttempt.value < props.retryCount) {
+          retryAttempt.value++;
+          if (props.debug) {
+            console.log(`[DJVRenderer] \u91CD\u8BD5 ${retryAttempt.value}/${props.retryCount}...`);
+          }
+          setTimeout(() => {
+            if (mounted.value) {
+              initWithRetry();
+            }
+          }, props.retryDelay);
+        } else {
+          phase.value = "error";
+          emit("phase-change", "error");
+          emit("error", error);
+        }
       }
     };
-    onMounted(() => {
-      initAndLoad();
+    const handleRetry = () => {
+      retryAttempt.value = 0;
+      initWithRetry();
+    };
+    onMounted2(() => {
+      mounted.value = true;
+      initWithRetry();
     });
     onUnmounted2(() => {
+      mounted.value = false;
       vueRuntime?.destroy();
     });
-    watch(
+    watch2(
       () => props.pageUid,
       () => {
         vueRuntime?.destroy();
-        initAndLoad();
+        retryAttempt.value = 0;
+        initWithRetry();
       }
     );
+    const renderDefaultLoading = () => {
+      return h("div", { class: "djvlc-loading" }, [
+        h("div", { class: "djvlc-loading-spinner" }),
+        h("span", {}, "\u52A0\u8F7D\u4E2D..."),
+        retryAttempt.value > 0 && h("span", { class: "djvlc-loading-retry" }, `\u91CD\u8BD5 ${retryAttempt.value}/${props.retryCount}`)
+      ]);
+    };
+    const renderDefaultError = (error) => {
+      return h("div", { class: "djvlc-error" }, [
+        h("div", { class: "djvlc-error-icon" }, "\u26A0\uFE0F"),
+        h("span", { class: "djvlc-error-message" }, `\u52A0\u8F7D\u5931\u8D25\uFF1A${error.message}`),
+        h(
+          "button",
+          {
+            class: "djvlc-error-retry-btn",
+            onClick: handleRetry,
+            type: "button"
+          },
+          "\u91CD\u8BD5"
+        )
+      ]);
+    };
+    const renderDefaultEmpty = () => {
+      return h("div", { class: "djvlc-empty" }, [h("span", {}, "\u6682\u65E0\u5185\u5BB9")]);
+    };
     return () => {
+      const isLoading = vueRuntime?.loading.value ?? false;
+      const currentError = vueRuntime?.error.value;
+      const currentPage = vueRuntime?.page.value;
       return h(
         "div",
         {
           ref: containerRef,
-          class: "djvlc-renderer"
+          class: "djvlc-renderer",
+          "data-phase": phase.value,
+          "data-page-uid": props.pageUid
         },
         [
           // 加载中插槽
-          vueRuntime?.loading.value && slots.loading?.(),
+          isLoading && (slots.loading?.() || renderDefaultLoading()),
           // 错误插槽
-          vueRuntime?.error.value && slots.error?.({ error: vueRuntime.error.value }),
+          currentError && (slots.error?.({ error: currentError, retry: handleRetry }) || renderDefaultError(currentError)),
+          // 空状态
+          !isLoading && !currentError && !currentPage && phase.value === "ready" && (slots.empty?.() || renderDefaultEmpty()),
           // 默认插槽（额外内容）
           slots.default?.()
         ]
@@ -386,7 +797,22 @@ var DJVRenderer = defineComponent({
 });
 
 // src/components/DJVProvider.ts
-import { defineComponent as defineComponent2, shallowRef as shallowRef3, h as h2 } from "vue";
+import {
+  defineComponent as defineComponent2,
+  shallowRef as shallowRef4,
+  watch as watch3,
+  onUnmounted as onUnmounted3,
+  h as h2
+} from "vue";
+var defaultState = {
+  phase: "idle",
+  page: null,
+  variables: {},
+  queries: {},
+  components: /* @__PURE__ */ new Map(),
+  error: null,
+  destroyed: false
+};
 var DJVProvider = defineComponent2({
   name: "DJVProvider",
   props: {
@@ -397,49 +823,219 @@ var DJVProvider = defineComponent2({
     hostApi: {
       type: Object,
       default: null
+    },
+    class: {
+      type: String,
+      default: ""
+    },
+    debug: {
+      type: Boolean,
+      default: false
     }
   },
-  setup(props, { slots }) {
-    const contextValue = shallowRef3({
+  emits: ["state-change", "phase-change", "error"],
+  setup(props, { slots, emit }) {
+    let unsubscribe = null;
+    const contextValue = shallowRef4({
       runtime: props.runtime,
-      state: props.runtime?.getState() || {
-        phase: "idle",
-        page: null,
-        variables: {},
-        queries: {},
-        components: /* @__PURE__ */ new Map(),
-        error: null,
-        destroyed: false
-      },
+      state: props.runtime?.getState() || defaultState,
       hostApi: props.hostApi
     });
     provideRuntime(contextValue);
-    if (props.runtime) {
-      props.runtime.onStateChange((state) => {
+    const subscribeToRuntime = (runtime) => {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+      if (!runtime) return;
+      unsubscribe = runtime.onStateChange((state) => {
+        const prevPhase = contextValue.value.state.phase;
         contextValue.value = {
           ...contextValue.value,
           state
         };
+        emit("state-change", state);
+        if (state.phase !== prevPhase) {
+          emit("phase-change", state.phase);
+          if (props.debug) {
+            console.log(`[DJVProvider] Phase changed: ${prevPhase} -> ${state.phase}`);
+          }
+        }
+        if (state.error) {
+          emit("error", state.error);
+        }
       });
-    }
-    return () => h2("div", { class: "djvlc-provider" }, slots.default?.());
+    };
+    subscribeToRuntime(props.runtime);
+    watch3(
+      () => props.runtime,
+      (newRuntime, oldRuntime) => {
+        if (newRuntime !== oldRuntime) {
+          contextValue.value = {
+            runtime: newRuntime,
+            state: newRuntime?.getState() || defaultState,
+            hostApi: props.hostApi
+          };
+          subscribeToRuntime(newRuntime);
+        }
+      }
+    );
+    watch3(
+      () => props.hostApi,
+      (newHostApi) => {
+        contextValue.value = {
+          ...contextValue.value,
+          hostApi: newHostApi
+        };
+      }
+    );
+    onUnmounted3(() => {
+      if (unsubscribe) {
+        unsubscribe();
+        unsubscribe = null;
+      }
+    });
+    return () => h2(
+      "div",
+      {
+        class: ["djvlc-provider", props.class].filter(Boolean).join(" "),
+        "data-phase": contextValue.value.state.phase
+      },
+      slots.default?.()
+    );
   }
 });
 
 // src/plugin.ts
+var DJVLC_CONFIG_KEY = "djvlc-config";
+function createTrackDirective() {
+  const observedElements = /* @__PURE__ */ new WeakSet();
+  return {
+    mounted(el, binding) {
+      const { event, data = {}, trigger = "click" } = binding.value;
+      if (trigger === "click") {
+        el.addEventListener("click", () => {
+          dispatchTrackEvent(event, { ...data, element: el.tagName });
+        });
+      } else if (trigger === "view") {
+        if (!observedElements.has(el)) {
+          observedElements.add(el);
+          const observer = new IntersectionObserver(
+            (entries) => {
+              entries.forEach((entry) => {
+                if (entry.isIntersecting) {
+                  dispatchTrackEvent(event, { ...data, element: el.tagName });
+                  observer.unobserve(el);
+                }
+              });
+            },
+            { threshold: 0.5 }
+          );
+          observer.observe(el);
+        }
+      } else if (trigger === "mounted") {
+        dispatchTrackEvent(event, { ...data, element: el.tagName });
+      }
+    }
+  };
+}
+function dispatchTrackEvent(event, data) {
+  window.dispatchEvent(
+    new CustomEvent("djvlc:track", {
+      detail: { event, data, timestamp: Date.now() }
+    })
+  );
+}
+function createVisibleDirective() {
+  return {
+    mounted(el, binding) {
+      updateVisibility(el, binding.value);
+    },
+    updated(el, binding) {
+      updateVisibility(el, binding.value);
+    }
+  };
+}
+function updateVisibility(el, visible) {
+  el.style.display = visible ? "" : "none";
+}
+function createLoadingDirective() {
+  const loadingOverlays = /* @__PURE__ */ new WeakMap();
+  return {
+    mounted(el, binding) {
+      el.style.position = "relative";
+      updateLoading(el, binding.value, loadingOverlays);
+    },
+    updated(el, binding) {
+      updateLoading(el, binding.value, loadingOverlays);
+    },
+    unmounted(el) {
+      const overlay = loadingOverlays.get(el);
+      if (overlay) {
+        overlay.remove();
+        loadingOverlays.delete(el);
+      }
+    }
+  };
+}
+function updateLoading(el, loading, overlays) {
+  let overlay = overlays.get(el);
+  if (loading) {
+    if (!overlay) {
+      overlay = document.createElement("div");
+      overlay.className = "djvlc-loading-overlay";
+      overlay.innerHTML = `
+        <div class="djvlc-loading-spinner"></div>
+      `;
+      overlay.style.cssText = `
+        position: absolute;
+        inset: 0;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        background: rgba(255, 255, 255, 0.8);
+        z-index: 100;
+      `;
+      el.appendChild(overlay);
+      overlays.set(el, overlay);
+    }
+    overlay.style.display = "flex";
+  } else if (overlay) {
+    overlay.style.display = "none";
+  }
+}
 var DJVPlugin = {
   install(app, options = {}) {
+    const prefix = options.componentPrefix || "";
     if (options.registerComponents !== false) {
-      app.component("DJVRenderer", DJVRenderer);
-      app.component("DJVProvider", DJVProvider);
+      app.component(`${prefix}DJVRenderer`, DJVRenderer);
+      app.component(`${prefix}DJVProvider`, DJVProvider);
     }
-    app.provide("djvlc-config", {
-      apiBaseUrl: options.defaultApiBaseUrl,
-      cdnBaseUrl: options.defaultCdnBaseUrl
-    });
+    if (options.registerDirectives !== false) {
+      app.directive("djv-track", createTrackDirective());
+      app.directive("djv-visible", createVisibleDirective());
+      app.directive("djv-loading", createLoadingDirective());
+    }
+    const globalConfig = {
+      apiBaseUrl: options.apiBaseUrl,
+      cdnBaseUrl: options.cdnBaseUrl,
+      channel: options.channel,
+      debug: options.debug,
+      enableSRI: options.enableSRI,
+      enableMetrics: options.enableMetrics,
+      retryCount: options.retryCount,
+      retryDelay: options.retryDelay,
+      timeout: options.timeout
+    };
+    app.provide(DJVLC_CONFIG_KEY, globalConfig);
+    app.config.globalProperties.$djvlc = {
+      config: globalConfig,
+      track: dispatchTrackEvent
+    };
   }
 };
 export {
+  DJVLC_CONFIG_KEY,
   DJVPlugin,
   DJVProvider,
   DJVRenderer,
@@ -448,11 +1044,17 @@ export {
   injectRuntime,
   provideRuntime,
   useAction,
+  useComponentState,
   useDJVRuntime,
   useData,
+  useDebouncedAction,
+  useGlobalConfig,
   useHostApi,
+  useLifecycle,
+  usePageInfo,
   useQuery,
   useRuntimeEvent,
   useRuntimeState,
-  useRuntimeStateWritable
+  useRuntimeStateWritable,
+  useWhen
 };