@avsbhq/vue 1.0.0

package/dist/index.cjs

@@ -0,0 +1,522 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AvsbInjectionKey: () => AvsbInjectionKey,
+  AvsbPlugin: () => AvsbPlugin,
+  AvsbProvider: () => AvsbProvider,
+  useAlias: () => useAlias,
+  useAllFlags: () => useAllFlags,
+  useAvsbClient: () => useAvsbClient,
+  useAvsbStore: () => useAvsbStore,
+  useBoolFlag: () => useBoolFlag,
+  useFlag: () => useFlag,
+  useFlagReady: () => useFlagReady,
+  useFlagValue: () => useFlagValue,
+  useIdentify: () => useIdentify,
+  useJsonFlag: () => useJsonFlag,
+  useNumberFlag: () => useNumberFlag,
+  useStringFlag: () => useStringFlag,
+  useTrack: () => useTrack
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/AvsbProvider.ts
+var import_vue2 = require("vue");
+var import_browser = require("@avsbhq/browser");
+
+// src/context.ts
+var import_vue = require("vue");
+var AvsbInjectionKey = /* @__PURE__ */ Symbol("avsb-injection-key");
+function useAvsbContext() {
+  const v = (0, import_vue.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 = (0, import_vue2.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 import_browser.AvsbClient(opts);
+    }
+    const activeClient = isInjectionMode ? injectedClient : ownedClient;
+    const status = (0, import_vue2.ref)("loading");
+    const error = (0, import_vue2.ref)(void 0);
+    (0, import_vue2.provide)(AvsbInjectionKey, {
+      get client() {
+        return activeClient;
+      },
+      get status() {
+        return status.value;
+      },
+      get error() {
+        return error.value;
+      }
+    });
+    let cancelled = false;
+    let unsubscribeError;
+    (0, import_vue2.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;
+          }
+        });
+      }
+    });
+    (0, import_vue2.onUnmounted)(() => {
+      cancelled = true;
+      unsubscribeError?.();
+      if (!isInjectionMode && ownedClient) {
+        ownedClient.close().catch(() => {
+        });
+        ownedClient = null;
+      }
+    });
+    return () => slots.default?.();
+  },
+  render() {
+    return (0, import_vue2.h)("div");
+  }
+});
+
+// src/plugin.ts
+var import_vue3 = require("vue");
+var import_browser2 = require("@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 import_browser2.AvsbClient(opts);
+    }
+    const status = (0, import_vue3.ref)("loading");
+    const error = (0, import_vue3.ref)(void 0);
+    app.provide(AvsbInjectionKey, {
+      get client() {
+        return activeClient;
+      },
+      get status() {
+        return status.value;
+      },
+      get error() {
+        return error.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);
+        }
+      });
+    }
+  }
+};
+
+// src/composables/useFlag.ts
+var import_vue4 = require("vue");
+var import_core = require("@avsbhq/core");
+function useFlag(flagKey, defaultValue) {
+  const { client } = useAvsbContext();
+  const noClientSentinel = (0, import_core.notFoundFlag)(defaultValue, "no client");
+  const flagRef = (0, import_vue4.ref)(
+    client !== null && typeof client.getSnapshot === "function" ? client.getSnapshot(
+      (0, import_vue4.isRef)(flagKey) ? flagKey.value : flagKey,
+      defaultValue
+    ) : noClientSentinel
+  );
+  let unsub;
+  function resubscribe() {
+    unsub?.();
+    unsub = void 0;
+    if (!client || typeof client.subscribe !== "function") return;
+    const key = (0, import_vue4.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(
+          (0, import_vue4.isRef)(flagKey) ? flagKey.value : flagKey,
+          defaultValue
+        );
+      }
+    });
+  }
+  let stopWatcher;
+  (0, import_vue4.onMounted)(() => {
+    if ((0, import_vue4.isRef)(flagKey)) {
+      stopWatcher = (0, import_vue4.watchEffect)(() => {
+        void flagKey.value;
+        resubscribe();
+      });
+    } else {
+      resubscribe();
+    }
+  });
+  (0, import_vue4.onUnmounted)(() => {
+    stopWatcher?.();
+    unsub?.();
+  });
+  return (0, import_vue4.computed)(() => flagRef.value);
+}
+
+// src/composables/useFlagValue.ts
+var import_vue5 = require("vue");
+function useFlagValue(flagKey, defaultValue) {
+  const flag = useFlag(flagKey, defaultValue);
+  return (0, import_vue5.computed)(() => flag.value.value);
+}
+
+// src/composables/useBoolFlag.ts
+var import_vue6 = require("vue");
+var import_core2 = require("@avsbhq/core");
+function useBoolFlag(flagKey, defaultValue) {
+  const { client } = useAvsbContext();
+  const noClientSentinel = (0, import_core2.notFoundFlag)(defaultValue, "no client");
+  const flagRef = (0, import_vue6.ref)(
+    client !== null && typeof client.getBoolFlag === "function" ? client.getBoolFlag(flagKey, defaultValue) : noClientSentinel
+  );
+  let unsub;
+  (0, import_vue6.onMounted)(() => {
+    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);
+      }
+    });
+  });
+  (0, import_vue6.onUnmounted)(() => {
+    unsub?.();
+  });
+  return (0, import_vue6.computed)(() => flagRef.value);
+}
+
+// src/composables/useStringFlag.ts
+var import_vue7 = require("vue");
+var import_core3 = require("@avsbhq/core");
+function useStringFlag(flagKey, defaultValue) {
+  const { client } = useAvsbContext();
+  const noClientSentinel = (0, import_core3.notFoundFlag)(defaultValue, "no client");
+  const flagRef = (0, import_vue7.ref)(
+    client !== null && typeof client.getStringFlag === "function" ? client.getStringFlag(flagKey, defaultValue) : noClientSentinel
+  );
+  let unsub;
+  (0, import_vue7.onMounted)(() => {
+    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);
+      }
+    });
+  });
+  (0, import_vue7.onUnmounted)(() => {
+    unsub?.();
+  });
+  return (0, import_vue7.computed)(() => flagRef.value);
+}
+
+// src/composables/useNumberFlag.ts
+var import_vue8 = require("vue");
+var import_core4 = require("@avsbhq/core");
+function useNumberFlag(flagKey, defaultValue) {
+  const { client } = useAvsbContext();
+  const noClientSentinel = (0, import_core4.notFoundFlag)(defaultValue, "no client");
+  const flagRef = (0, import_vue8.ref)(
+    client !== null && typeof client.getNumberFlag === "function" ? client.getNumberFlag(flagKey, defaultValue) : noClientSentinel
+  );
+  let unsub;
+  (0, import_vue8.onMounted)(() => {
+    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);
+      }
+    });
+  });
+  (0, import_vue8.onUnmounted)(() => {
+    unsub?.();
+  });
+  return (0, import_vue8.computed)(() => flagRef.value);
+}
+
+// src/composables/useJsonFlag.ts
+var import_vue9 = require("vue");
+var import_core5 = require("@avsbhq/core");
+function useJsonFlag(flagKey, defaultValue) {
+  const { client } = useAvsbContext();
+  const noClientSentinel = (0, import_core5.notFoundFlag)(defaultValue, "no client");
+  const flagRef = (0, import_vue9.ref)(
+    client !== null && typeof client.getJsonFlag === "function" ? client.getJsonFlag(flagKey, defaultValue) : noClientSentinel
+  );
+  let unsub;
+  (0, import_vue9.onMounted)(() => {
+    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);
+      }
+    });
+  });
+  (0, import_vue9.onUnmounted)(() => {
+    unsub?.();
+  });
+  return (0, import_vue9.computed)(() => flagRef.value);
+}
+
+// src/composables/useAllFlags.ts
+var import_vue10 = require("vue");
+function useAllFlags() {
+  const { client } = useAvsbContext();
+  const snapshotRef = (0, import_vue10.ref)(
+    client !== null && typeof client.getAllFlags === "function" ? client.getAllFlags() : {}
+  );
+  let unsub;
+  (0, import_vue10.onMounted)(() => {
+    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();
+      }
+    });
+  });
+  (0, import_vue10.onUnmounted)(() => {
+    unsub?.();
+  });
+  return (0, import_vue10.computed)(() => snapshotRef.value);
+}
+
+// src/composables/useFlagReady.ts
+var import_vue11 = require("vue");
+function useFlagReady() {
+  const context = useAvsbContext();
+  return (0, import_vue11.computed)(() => context.status === "ready");
+}
+
+// src/composables/useAvsbClient.ts
+function useAvsbClient() {
+  const { client } = useAvsbContext();
+  return client;
+}
+
+// src/composables/useIdentify.ts
+var import_vue12 = require("vue");
+function useIdentify() {
+  const { client } = useAvsbContext();
+  const clientRef = (0, import_vue12.ref)(client);
+  clientRef.value = client;
+  function identify(ctx) {
+    const c = clientRef.value;
+    if (!c || typeof c.identify !== "function") return;
+    c.identify(ctx);
+  }
+  return identify;
+}
+
+// src/composables/useAlias.ts
+var import_vue13 = require("vue");
+function useAlias() {
+  const { client } = useAvsbContext();
+  const clientRef = (0, import_vue13.ref)(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;
+}
+
+// src/composables/useTrack.ts
+var import_vue14 = require("vue");
+function useTrack() {
+  const { client } = useAvsbContext();
+  const clientRef = (0, import_vue14.ref)(client);
+  clientRef.value = client;
+  function track(eventKey, payload) {
+    const c = clientRef.value;
+    if (!c || typeof c.track !== "function") return;
+    c.track(eventKey, payload);
+  }
+  return track;
+}
+
+// src/pinia.ts
+var import_pinia = require("pinia");
+var import_vue15 = require("vue");
+var import_vue16 = require("vue");
+var useAvsbStore = (0, import_pinia.defineStore)("avsb", () => {
+  const injectedContext = (0, import_vue16.inject)(AvsbInjectionKey);
+  const _client = (0, import_vue15.ref)(injectedContext?.client ?? null);
+  const _status = (0, import_vue15.ref)(
+    injectedContext?.status ?? "loading"
+  );
+  const _error = (0, import_vue15.ref)(injectedContext?.error);
+  if (injectedContext) {
+  }
+  const client = (0, import_vue15.computed)(
+    () => injectedContext ? injectedContext.client : _client.value
+  );
+  const status = (0, import_vue15.computed)(
+    () => injectedContext ? injectedContext.status : _status.value
+  );
+  const error = (0, import_vue15.computed)(
+    () => 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));
+    });
+  }
+  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
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AvsbInjectionKey,
+  AvsbPlugin,
+  AvsbProvider,
+  useAlias,
+  useAllFlags,
+  useAvsbClient,
+  useAvsbStore,
+  useBoolFlag,
+  useFlag,
+  useFlagReady,
+  useFlagValue,
+  useIdentify,
+  useJsonFlag,
+  useNumberFlag,
+  useStringFlag,
+  useTrack
+});