@avsbhq/vue 1.0.1 → 1.1.0

package/dist/index.js

@@ -1,217 +1,85 @@
-// src/AvsbProvider.ts
 import {
-  defineComponent,
-  ref,
-  provide,
-  onMounted,
-  onUnmounted,
-  h
-} from "vue";
-import { AvsbClient } from "@avsbhq/browser";
-
-// src/context.ts
-import { inject } from "vue";
-var AvsbInjectionKey = /* @__PURE__ */ Symbol("avsb-injection-key");
-function useAvsbContext() {
-  const v = inject(AvsbInjectionKey);
-  if (v === void 0) {
-    throw new Error(
-      '[avsb] composables must be used inside <AvsbProvider> or app.use(AvsbPlugin). Wrap your component tree with <AvsbProvider sdkKey="..." context={...}> or install the plugin.'
-    );
-  }
-  return v;
-}
-
-// src/AvsbProvider.ts
-var AvsbProvider = defineComponent({
-  name: "AvsbProvider",
-  props: {
-    // Mode B — caller passes a pre-built client
-    client: {
-      type: Object,
-      default: void 0
-    },
-    // Mode A — sdkKey is the minimum required field from AvsbClientOptions
-    sdkKey: {
-      type: String,
-      default: void 0
-    }
-  },
-  // Accept any additional option props (pollingInterval, bootstrap, etc.)
-  // via inheritAttrs + $attrs so callers can pass the full AvsbClientOptions
-  // surface without enumerating every field as a prop.
-  inheritAttrs: false,
-  setup(props, { slots, attrs }) {
-    const injectedClient = props.client ?? null;
-    const isInjectionMode = injectedClient !== null;
-    let ownedClient = null;
-    if (!isInjectionMode) {
-      if (!props.sdkKey) {
-        throw new Error(
-          "[avsb] <AvsbProvider> requires either a `client` prop (Mode B) or a `sdkKey` prop (Mode A)."
-        );
-      }
-      const opts = {
-        sdkKey: props.sdkKey,
-        ...attrs
-      };
-      ownedClient = new AvsbClient(opts);
-    }
-    const activeClient = isInjectionMode ? injectedClient : ownedClient;
-    const status = ref("loading");
-    const error = ref(void 0);
-    provide(AvsbInjectionKey, {
-      get client() {
-        return activeClient;
-      },
-      get status() {
-        return status.value;
-      },
-      get error() {
-        return error.value;
-      }
-    });
-    let cancelled = false;
-    let unsubscribeError;
-    onMounted(() => {
-      if (!activeClient) return;
-      activeClient.onReady().then(() => {
-        if (!cancelled) status.value = "ready";
-      }).catch((err) => {
-        if (!cancelled) {
-          status.value = "error";
-          error.value = err instanceof Error ? err : new Error(String(err));
-        }
-      });
-      if (typeof activeClient.on === "function") {
-        unsubscribeError = activeClient.on("error", (e) => {
-          if (!cancelled) {
-            status.value = "error";
-            error.value = e;
-          }
-        });
-      }
-    });
-    onUnmounted(() => {
-      cancelled = true;
-      unsubscribeError?.();
-      if (!isInjectionMode && ownedClient) {
-        ownedClient.close().catch(() => {
-        });
-        ownedClient = null;
-      }
-    });
-    return () => slots.default?.();
-  },
-  render() {
-    return h("div");
-  }
-});
+  AvsbProvider,
+  createProviderState,
+  resolveClient
+} from "./chunk-7A3YSHQG.js";
+import {
+  AvsbInjectionKey,
+  useAvsbContext
+} from "./chunk-4XBADQFO.js";
 
 // src/plugin.ts
-import { ref as ref2 } from "vue";
-import { AvsbClient as AvsbClient2 } from "@avsbhq/browser";
 var AvsbPlugin = {
   install(app, options) {
-    const injectedClient = "client" in options && options.client ? options.client : null;
-    const isInjectionMode = injectedClient !== null;
-    let activeClient;
-    if (isInjectionMode) {
-      activeClient = injectedClient;
-    } else {
-      const opts = options;
-      activeClient = new AvsbClient2(opts);
-    }
-    const status = ref2("loading");
-    const error = ref2(void 0);
+    const { sdkKey, context, bootstrap, client: injected, ...rest } = options;
+    const { client, owned } = resolveClient({
+      ...injected ? { client: injected } : { sdkKey },
+      ...context !== void 0 ? { context } : {},
+      ...bootstrap !== void 0 ? { bootstrap } : {},
+      options: rest
+    });
+    const state = createProviderState(client);
     app.provide(AvsbInjectionKey, {
-      get client() {
-        return activeClient;
-      },
+      client,
       get status() {
-        return status.value;
+        return state.status.value;
       },
       get error() {
-        return error.value;
+        return state.error.value;
+      },
+      get degraded() {
+        return state.degraded.value;
       }
     });
-    activeClient.onReady().then(() => {
-      status.value = "ready";
-    }).catch((err) => {
-      status.value = "error";
-      error.value = err instanceof Error ? err : new Error(String(err));
-    });
-    if (typeof activeClient.on === "function") {
-      activeClient.on("error", (e) => {
-        status.value = "error";
-        error.value = e;
-      });
-    }
-    if (!isInjectionMode) {
-      app.unmount = new Proxy(app.unmount, {
-        apply(target, thisArg, args) {
-          activeClient.close().catch(() => {
-          });
-          return Reflect.apply(target, thisArg, args);
-        }
-      });
-    }
+    const unmount = app.unmount.bind(app);
+    app.unmount = () => {
+      state.stop();
+      if (owned) void client.close();
+      unmount();
+    };
   }
 };
 
-// src/composables/useFlag.ts
+// src/internal/bindFlagRef.ts
 import {
-  ref as ref3,
   computed,
-  onMounted as onMounted2,
-  onUnmounted as onUnmounted2,
-  watchEffect,
-  isRef
+  isRef,
+  onScopeDispose,
+  shallowRef,
+  watch
 } from "vue";
-import { notFoundFlag } from "@avsbhq/core";
-function useFlag(flagKey, defaultValue) {
-  const { client } = useAvsbContext();
-  const noClientSentinel = notFoundFlag(defaultValue, "no client");
-  const flagRef = ref3(
-    client !== null && typeof client.getSnapshot === "function" ? client.getSnapshot(
-      isRef(flagKey) ? flagKey.value : flagKey,
-      defaultValue
-    ) : noClientSentinel
-  );
-  let unsub;
-  function resubscribe() {
-    unsub?.();
-    unsub = void 0;
-    if (!client || typeof client.subscribe !== "function") return;
-    const key = isRef(flagKey) ? flagKey.value : flagKey;
-    if (typeof client.getSnapshot === "function") {
-      flagRef.value = client.getSnapshot(key, defaultValue);
-    }
-    unsub = client.subscribe(key, () => {
-      if (typeof client.getSnapshot === "function") {
-        flagRef.value = client.getSnapshot(
-          isRef(flagKey) ? flagKey.value : flagKey,
-          defaultValue
-        );
-      }
+var RENDER_SAFE = { readOnly: true };
+function resolveFlagKey(flagKey) {
+  return isRef(flagKey) ? flagKey.value : flagKey;
+}
+function bindFlagRef(client, flagKey, read) {
+  const current = shallowRef(read(client, resolveFlagKey(flagKey)));
+  let unsubscribe;
+  const subscribe = (key) => {
+    unsubscribe?.();
+    current.value = read(client, key);
+    unsubscribe = client.subscribe(key, () => {
+      current.value = read(client, key);
     });
-  }
-  let stopWatcher;
-  onMounted2(() => {
-    if (isRef(flagKey)) {
-      stopWatcher = watchEffect(() => {
-        void flagKey.value;
-        resubscribe();
-      });
-    } else {
-      resubscribe();
-    }
-  });
-  onUnmounted2(() => {
+  };
+  subscribe(resolveFlagKey(flagKey));
+  const stopWatcher = isRef(flagKey) ? watch(flagKey, (next) => subscribe(next), { flush: "sync" }) : void 0;
+  onScopeDispose(() => {
     stopWatcher?.();
-    unsub?.();
+    unsubscribe?.();
+    unsubscribe = void 0;
   });
-  return computed(() => flagRef.value);
+  return computed(() => current.value);
+}
+
+// src/composables/useFlag.ts
+function useFlag(flagKey, defaultValue) {
+  const { client } = useAvsbContext();
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getSnapshot(key, defaultValue)
+  );
 }
 
 // src/composables/useFlagValue.ts
@@ -222,298 +90,194 @@ function useFlagValue(flagKey, defaultValue) {
 }
 
 // src/composables/useBoolFlag.ts
-import {
-  ref as ref4,
-  computed as computed3,
-  onMounted as onMounted3,
-  onUnmounted as onUnmounted3
-} from "vue";
-import { notFoundFlag as notFoundFlag2 } from "@avsbhq/core";
 function useBoolFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = notFoundFlag2(defaultValue, "no client");
-  const flagRef = ref4(
-    client !== null && typeof client.getBoolFlag === "function" ? client.getBoolFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getBoolFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  onMounted3(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getBoolFlag === "function") {
-      flagRef.value = client.getBoolFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getBoolFlag === "function") {
-        flagRef.value = client.getBoolFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  onUnmounted3(() => {
-    unsub?.();
-  });
-  return computed3(() => flagRef.value);
 }
 
 // src/composables/useStringFlag.ts
-import {
-  ref as ref5,
-  computed as computed4,
-  onMounted as onMounted4,
-  onUnmounted as onUnmounted4
-} from "vue";
-import { notFoundFlag as notFoundFlag3 } from "@avsbhq/core";
 function useStringFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = notFoundFlag3(defaultValue, "no client");
-  const flagRef = ref5(
-    client !== null && typeof client.getStringFlag === "function" ? client.getStringFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getStringFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  onMounted4(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getStringFlag === "function") {
-      flagRef.value = client.getStringFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getStringFlag === "function") {
-        flagRef.value = client.getStringFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  onUnmounted4(() => {
-    unsub?.();
-  });
-  return computed4(() => flagRef.value);
 }
 
 // src/composables/useNumberFlag.ts
-import {
-  ref as ref6,
-  computed as computed5,
-  onMounted as onMounted5,
-  onUnmounted as onUnmounted5
-} from "vue";
-import { notFoundFlag as notFoundFlag4 } from "@avsbhq/core";
 function useNumberFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = notFoundFlag4(defaultValue, "no client");
-  const flagRef = ref6(
-    client !== null && typeof client.getNumberFlag === "function" ? client.getNumberFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getNumberFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  onMounted5(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getNumberFlag === "function") {
-      flagRef.value = client.getNumberFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getNumberFlag === "function") {
-        flagRef.value = client.getNumberFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  onUnmounted5(() => {
-    unsub?.();
-  });
-  return computed5(() => flagRef.value);
 }
 
 // src/composables/useJsonFlag.ts
-import {
-  ref as ref7,
-  computed as computed6,
-  onMounted as onMounted6,
-  onUnmounted as onUnmounted6
-} from "vue";
-import { notFoundFlag as notFoundFlag5 } from "@avsbhq/core";
 function useJsonFlag(flagKey, defaultValue) {
   const { client } = useAvsbContext();
-  const noClientSentinel = notFoundFlag5(defaultValue, "no client");
-  const flagRef = ref7(
-    client !== null && typeof client.getJsonFlag === "function" ? client.getJsonFlag(flagKey, defaultValue) : noClientSentinel
+  return bindFlagRef(
+    client,
+    flagKey,
+    (c, key) => c.getJsonFlag(key, defaultValue, RENDER_SAFE)
   );
-  let unsub;
-  onMounted6(() => {
-    if (!client || typeof client.subscribe !== "function") return;
-    if (typeof client.getJsonFlag === "function") {
-      flagRef.value = client.getJsonFlag(flagKey, defaultValue);
-    }
-    unsub = client.subscribe(flagKey, () => {
-      if (typeof client.getJsonFlag === "function") {
-        flagRef.value = client.getJsonFlag(flagKey, defaultValue);
-      }
-    });
-  });
-  onUnmounted6(() => {
-    unsub?.();
-  });
-  return computed6(() => flagRef.value);
 }
 
 // src/composables/useAllFlags.ts
 import {
-  ref as ref8,
-  computed as computed7,
-  onMounted as onMounted7,
-  onUnmounted as onUnmounted7
+  computed as computed3,
+  onScopeDispose as onScopeDispose2,
+  shallowRef as shallowRef2
 } from "vue";
 function useAllFlags() {
   const { client } = useAvsbContext();
-  const snapshotRef = ref8(
-    client !== null && typeof client.getAllFlags === "function" ? client.getAllFlags() : {}
-  );
-  let unsub;
-  onMounted7(() => {
-    if (!client || typeof client.on !== "function") return;
-    if (typeof client.getAllFlags === "function") {
-      snapshotRef.value = client.getAllFlags();
-    }
-    unsub = client.on("flagChange", () => {
-      if (typeof client.getAllFlags === "function") {
-        snapshotRef.value = client.getAllFlags();
-      }
-    });
+  const current = shallowRef2(client.getAllFlags());
+  const unsubscribe = client.on("flagChange", () => {
+    current.value = client.getAllFlags();
   });
-  onUnmounted7(() => {
-    unsub?.();
-  });
-  return computed7(() => snapshotRef.value);
+  onScopeDispose2(unsubscribe);
+  return computed3(() => current.value);
 }
 
 // src/composables/useFlagReady.ts
-import { computed as computed8 } from "vue";
+import { computed as computed4 } from "vue";
 function useFlagReady() {
   const context = useAvsbContext();
-  return computed8(() => context.status === "ready");
+  return computed4(() => context.status === "ready");
+}
+
+// src/composables/useAvsbStatus.ts
+import { computed as computed5 } from "vue";
+function useAvsbStatus() {
+  const context = useAvsbContext();
+  return {
+    status: computed5(() => context.status),
+    error: computed5(() => context.error),
+    degraded: computed5(() => context.degraded)
+  };
 }
 
 // src/composables/useAvsbClient.ts
 function useAvsbClient() {
-  const { client } = useAvsbContext();
-  return client;
+  return useAvsbContext().client;
 }
 
 // src/composables/useIdentify.ts
-import { ref as ref9 } from "vue";
 function useIdentify() {
   const { client } = useAvsbContext();
-  const clientRef = ref9(client);
-  clientRef.value = client;
-  function identify(ctx) {
-    const c = clientRef.value;
-    if (!c || typeof c.identify !== "function") return;
-    c.identify(ctx);
-  }
-  return identify;
+  return (context) => {
+    client.identify(context);
+  };
 }
 
 // src/composables/useAlias.ts
-import { ref as ref10 } from "vue";
 function useAlias() {
   const { client } = useAvsbContext();
-  const clientRef = ref10(client);
-  clientRef.value = client;
-  async function alias(prev, next) {
-    const c = clientRef.value;
-    if (!c || typeof c.alias !== "function") return;
-    await c.alias(prev, next);
-  }
-  return alias;
+  return (previousContext, newContext) => {
+    client.alias(previousContext, newContext);
+  };
+}
+
+// src/composables/useReset.ts
+function useReset() {
+  const { client } = useAvsbContext();
+  return () => {
+    client.reset();
+  };
 }
 
 // src/composables/useTrack.ts
-import { ref as ref11 } from "vue";
 function useTrack() {
   const { client } = useAvsbContext();
-  const clientRef = ref11(client);
-  clientRef.value = client;
-  function track(eventKey, payload) {
-    const c = clientRef.value;
-    if (!c || typeof c.track !== "function") return;
-    c.track(eventKey, payload);
+  return (eventKey, payload) => {
+    client.track(eventKey, payload);
+  };
+}
+
+// src/composables/useExposure.ts
+import { onMounted, onUnmounted, watch as watch2 } from "vue";
+
+// src/internal/fireExposure.ts
+function fireExposureWhenReady(client, flagKey) {
+  if (client.isReady()) {
+    client.getFlag(flagKey, null);
+    return () => {
+    };
   }
-  return track;
+  const off = client.on("ready", () => {
+    client.getFlag(flagKey, null);
+    off();
+  });
+  return off;
 }
 
-// src/pinia.ts
-import { defineStore } from "pinia";
-import { ref as ref12, computed as computed9 } from "vue";
-import { inject as inject2 } from "vue";
-var useAvsbStore = defineStore("avsb", () => {
-  const injectedContext = inject2(AvsbInjectionKey);
-  const _client = ref12(injectedContext?.client ?? null);
-  const _status = ref12(
-    injectedContext?.status ?? "loading"
-  );
-  const _error = ref12(injectedContext?.error);
-  if (injectedContext) {
+// src/composables/useExposure.ts
+function useExposure(flagKey) {
+  const { client } = useAvsbContext();
+  let cancel;
+  const fire = (key) => {
+    cancel?.();
+    cancel = fireExposureWhenReady(client, key);
+  };
+  onMounted(() => {
+    fire(resolveFlagKey(flagKey));
+  });
+  if (typeof flagKey !== "string") {
+    watch2(flagKey, (next) => fire(next));
   }
-  const client = computed9(
-    () => injectedContext ? injectedContext.client : _client.value
-  );
-  const status = computed9(
-    () => injectedContext ? injectedContext.status : _status.value
-  );
-  const error = computed9(
-    () => injectedContext ? injectedContext.error : _error.value
-  );
-  function setClient(c) {
-    _client.value = c;
-    _status.value = "loading";
-    _error.value = void 0;
-    if (!c) return;
-    c.onReady().then(() => {
-      _status.value = "ready";
-    }).catch((err) => {
-      _status.value = "error";
-      _error.value = err instanceof Error ? err : new Error(String(err));
+  onUnmounted(() => {
+    cancel?.();
+    cancel = void 0;
+  });
+}
+
+// src/composables/useFlagSubscription.ts
+import { onScopeDispose as onScopeDispose3, watch as watch3 } from "vue";
+function useFlagSubscription(flagKey, callback) {
+  const { client } = useAvsbContext();
+  let unsubscribe;
+  const subscribe = (key) => {
+    unsubscribe?.();
+    unsubscribe = client.subscribe(key, () => {
+      callback(client.getSnapshot(key, void 0));
     });
-  }
-  function identify(ctx) {
-    const c = client.value;
-    if (!c || typeof c.identify !== "function") return;
-    c.identify(ctx);
-  }
-  function track(eventKey, payload) {
-    const c = client.value;
-    if (!c || typeof c.track !== "function") return;
-    c.track(eventKey, payload);
-  }
-  async function alias(prev, next) {
-    const c = client.value;
-    if (!c || typeof c.alias !== "function") return;
-    await c.alias(prev, next);
-  }
-  function reset() {
-    const c = client.value;
-    if (!c || typeof c.reset !== "function") return;
-    c.reset();
-  }
-  return {
-    client,
-    status,
-    error,
-    setClient,
-    identify,
-    track,
-    alias,
-    reset
   };
-});
+  subscribe(resolveFlagKey(flagKey));
+  const stopWatcher = typeof flagKey === "string" ? void 0 : watch3(flagKey, (next) => subscribe(next), { flush: "sync" });
+  onScopeDispose3(() => {
+    stopWatcher?.();
+    unsubscribe?.();
+    unsubscribe = void 0;
+  });
+}
+
+// src/index.ts
+import { DecideOption } from "@avsbhq/core";
 export {
   AvsbInjectionKey,
   AvsbPlugin,
   AvsbProvider,
+  DecideOption,
   useAlias,
   useAllFlags,
   useAvsbClient,
-  useAvsbStore,
+  useAvsbStatus,
   useBoolFlag,
+  useExposure,
   useFlag,
   useFlagReady,
+  useFlagSubscription,
   useFlagValue,
   useIdentify,
   useJsonFlag,
   useNumberFlag,
+  useReset,
   useStringFlag,
   useTrack
 };