@avsbhq/vue 1.0.2 → 1.1.1

package/dist/pinia.cjs

@@ -0,0 +1,74 @@
+"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/pinia.ts
+var pinia_exports = {};
+__export(pinia_exports, {
+  useAvsbStore: () => useAvsbStore
+});
+module.exports = __toCommonJS(pinia_exports);
+var import_pinia = require("pinia");
+var import_vue2 = require("vue");
+
+// src/context.ts
+var import_vue = require("vue");
+var AvsbInjectionKey = /* @__PURE__ */ Symbol("avsb-injection-key");
+function useAvsbContext() {
+  const value = (0, import_vue.inject)(AvsbInjectionKey);
+  if (value === void 0) {
+    throw new Error(
+      `[avsb] composables must be used inside <AvsbProvider> or app.use(AvsbPlugin). Wrap your component tree with <AvsbProvider sdk-key="sdk_production_..." :context="{ kind: 'user', key: userId }">, or install the plugin with app.use(AvsbPlugin, { sdkKey: 'sdk_production_...' }).`
+    );
+  }
+  return value;
+}
+
+// src/pinia.ts
+var useAvsbStore = (0, import_pinia.defineStore)("avsb", () => {
+  const context = useAvsbContext();
+  const client = context.client;
+  const allFlags = (0, import_vue2.shallowRef)(client.getAllFlags());
+  const unsubscribe = client.on("flagChange", () => {
+    allFlags.value = client.getAllFlags();
+  });
+  (0, import_vue2.onScopeDispose)(unsubscribe);
+  return {
+    client: (0, import_vue2.computed)(() => client),
+    status: (0, import_vue2.computed)(() => context.status),
+    error: (0, import_vue2.computed)(() => context.error),
+    degraded: (0, import_vue2.computed)(() => context.degraded),
+    flags: (0, import_vue2.computed)(() => allFlags.value),
+    identify: (evalContext) => {
+      client.identify(evalContext);
+    },
+    alias: (previousContext, newContext) => {
+      client.alias(previousContext, newContext);
+    },
+    reset: () => {
+      client.reset();
+    },
+    track: (eventKey, payload) => {
+      client.track(eventKey, payload);
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAvsbStore
+});

package/dist/pinia.d.cts

@@ -0,0 +1,23 @@
+import * as pinia from 'pinia';
+import { ComputedRef } from 'vue';
+import { Flag, EvalContext, TrackPayload } from '@avsbhq/core';
+import { V as VueAvsbClient } from './clientInterface-BMlQ7Uhe.cjs';
+import { d as AvsbStatus } from './types-DECMgjjk.cjs';
+import '@avsbhq/browser';
+
+interface AvsbStoreState {
+    /** The client the provider built or adopted. */
+    client: ComputedRef<VueAvsbClient>;
+    status: ComputedRef<AvsbStatus>;
+    error: ComputedRef<Error | undefined>;
+    degraded: ComputedRef<boolean>;
+    /** Every flag, refreshed whenever any flag changes. */
+    flags: ComputedRef<Record<string, Flag>>;
+    identify: (context: EvalContext) => void;
+    alias: (previousContext: EvalContext, newContext: EvalContext) => void;
+    reset: () => void;
+    track: (eventKey: string, payload?: TrackPayload) => void;
+}
+declare const useAvsbStore: pinia.StoreDefinition<"avsb", Pick<AvsbStoreState, never>, Pick<AvsbStoreState, "flags" | "client" | "error" | "status" | "degraded">, Pick<AvsbStoreState, "reset" | "track" | "identify" | "alias">>;
+
+export { type AvsbStoreState, useAvsbStore };

package/dist/pinia.d.ts

@@ -0,0 +1,23 @@
+import * as pinia from 'pinia';
+import { ComputedRef } from 'vue';
+import { Flag, EvalContext, TrackPayload } from '@avsbhq/core';
+import { V as VueAvsbClient } from './clientInterface-BMlQ7Uhe.js';
+import { d as AvsbStatus } from './types-Di6G-dj0.js';
+import '@avsbhq/browser';
+
+interface AvsbStoreState {
+    /** The client the provider built or adopted. */
+    client: ComputedRef<VueAvsbClient>;
+    status: ComputedRef<AvsbStatus>;
+    error: ComputedRef<Error | undefined>;
+    degraded: ComputedRef<boolean>;
+    /** Every flag, refreshed whenever any flag changes. */
+    flags: ComputedRef<Record<string, Flag>>;
+    identify: (context: EvalContext) => void;
+    alias: (previousContext: EvalContext, newContext: EvalContext) => void;
+    reset: () => void;
+    track: (eventKey: string, payload?: TrackPayload) => void;
+}
+declare const useAvsbStore: pinia.StoreDefinition<"avsb", Pick<AvsbStoreState, never>, Pick<AvsbStoreState, "flags" | "client" | "error" | "status" | "degraded">, Pick<AvsbStoreState, "reset" | "track" | "identify" | "alias">>;
+
+export { type AvsbStoreState, useAvsbStore };

package/dist/pinia.js

@@ -0,0 +1,38 @@
+import {
+  useAvsbContext
+} from "./chunk-4XBADQFO.js";
+
+// src/pinia.ts
+import { defineStore } from "pinia";
+import { computed, onScopeDispose, shallowRef } from "vue";
+var useAvsbStore = defineStore("avsb", () => {
+  const context = useAvsbContext();
+  const client = context.client;
+  const allFlags = shallowRef(client.getAllFlags());
+  const unsubscribe = client.on("flagChange", () => {
+    allFlags.value = client.getAllFlags();
+  });
+  onScopeDispose(unsubscribe);
+  return {
+    client: computed(() => client),
+    status: computed(() => context.status),
+    error: computed(() => context.error),
+    degraded: computed(() => context.degraded),
+    flags: computed(() => allFlags.value),
+    identify: (evalContext) => {
+      client.identify(evalContext);
+    },
+    alias: (previousContext, newContext) => {
+      client.alias(previousContext, newContext);
+    },
+    reset: () => {
+      client.reset();
+    },
+    track: (eventKey, payload) => {
+      client.track(eventKey, payload);
+    }
+  };
+});
+export {
+  useAvsbStore
+};

package/dist/testing.cjs

@@ -0,0 +1,279 @@
+"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/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  AvsbTestProvider: () => AvsbTestProvider,
+  createTestClient: () => createTestClient,
+  createTestDatafile: () => createTestDatafile
+});
+module.exports = __toCommonJS(testing_exports);
+var import_vue4 = require("vue");
+
+// ../avsb-test/dist/fixtures.js
+var import_browser = require("@avsbhq/browser");
+var TEST_SDK_KEY = "sdk_test_0000000000000000000";
+function flagType(value) {
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  return "json";
+}
+function entryFor(key, value, index) {
+  const variationId = `var_${index}`;
+  return {
+    id: `flag_${index}`,
+    key,
+    type: flagType(value),
+    enabled: true,
+    defaultVariationId: variationId,
+    variations: [{ id: variationId, key: "test", value }],
+    overrides: [],
+    rules: [
+      {
+        id: `rule_${index}`,
+        type: "ab_test",
+        enabled: true,
+        audienceIds: [],
+        hashAttribute: "user.key",
+        trafficAllocation: null,
+        // `percentage` is a 0..1 proportion (the evaluator multiplies it by
+        // 10000), so this is the whole audience.
+        variations: [{ variationId, percentage: 1 }]
+      }
+    ]
+  };
+}
+function createTestDatafile(flags, options) {
+  const mapped = Object.entries(flags ?? {}).map(
+    ([key, value], index) => entryFor(key, value, index)
+  );
+  return {
+    version: 2,
+    projectType: "FEATURE_FLAG",
+    sdkKey: options?.sdkKey ?? TEST_SDK_KEY,
+    environmentKey: options?.environmentKey ?? "test",
+    publishedAt: options?.publishedAt ?? "2024-01-01T00:00:00.000Z",
+    // An ORIGIN, the way the publisher writes it: SDKs append the
+    // `/v1/collect/*` paths themselves through the core endpoint contract.
+    // The `.invalid` TLD is reserved and never resolves, so a stray flush in
+    // a test cannot reach a real host.
+    collectEndpoint: "https://collect.test.invalid",
+    flags: [...mapped, ...options?.entries ?? []],
+    audiences: [],
+    holdouts: [],
+    bandits: [],
+    // `bigSegments` deliberately absent: the field was deleted from the
+    // datafile type (breaking change B28) because nothing evaluated it.
+    contextKinds: ["user"],
+    exposureSampling: 1
+  };
+}
+var TEST_CONTEXT = { kind: "user", key: "test-user" };
+function createTestClient(options) {
+  const datafile = options?.datafile ?? createTestDatafile(options?.flags ?? {});
+  const client = new import_browser.AvsbClient({
+    sdkKey: datafile.sdkKey || TEST_SDK_KEY,
+    context: options?.context ?? TEST_CONTEXT,
+    // No fetch at construction. The datafile arrives through the bootstrap
+    // handoff below, which is also what wires the tracker and settles
+    // `getInitResult()`, so `track` and `flush` behave as they do in
+    // production instead of queueing forever behind a tracker that a
+    // failed background fetch never created.
+    autoInit: false,
+    autoRefresh: false,
+    cache: false,
+    logLevel: "silent",
+    // Long enough that the automatic flush never fires mid-test. Assert on
+    // events with an explicit `await client.flush()`.
+    events: { flushInterval: 6e4 }
+  });
+  client.applyDatafileBootstrap(datafile);
+  return client;
+}
+
+// src/AvsbProvider.ts
+var import_vue3 = require("vue");
+var import_browser3 = require("@avsbhq/browser");
+var import_core = require("@avsbhq/core");
+
+// src/context.ts
+var import_vue = require("vue");
+var AvsbInjectionKey = /* @__PURE__ */ Symbol("avsb-injection-key");
+function hasAvsbContext() {
+  return (0, import_vue.inject)(AvsbInjectionKey, null) !== null;
+}
+
+// src/internal/providerState.ts
+var import_vue2 = require("vue");
+var UNEXPLAINED_FAILURE = "[avsb] the SDK could not load a datafile and nothing was cached or bootstrapped, so every flag is returning the default you passed. Check the SDK key on app.avsb.cloud under Environments in the project sidebar.";
+function createProviderState(client) {
+  const status = (0, import_vue2.ref)(client.isReady() ? "ready" : "loading");
+  const error = (0, import_vue2.shallowRef)(void 0);
+  const degraded = (0, import_vue2.ref)(false);
+  let stopped = false;
+  const applyInitResult = (result) => {
+    if (stopped) return;
+    if (result.success) {
+      status.value = "ready";
+      degraded.value = result.degraded === true;
+      error.value = result.error;
+      return;
+    }
+    status.value = "error";
+    error.value = result.error ?? new Error(UNEXPLAINED_FAILURE);
+  };
+  const settled = client.getInitResult();
+  if (settled) {
+    applyInitResult(settled);
+  } else {
+    void client.onReady().then(applyInitResult);
+  }
+  const offError = client.on("error", (e) => {
+    if (stopped) return;
+    error.value = e;
+    if (client.isReady()) {
+      degraded.value = true;
+      return;
+    }
+    status.value = "error";
+  });
+  const offReady = client.on("ready", applyInitResult);
+  return {
+    status,
+    error,
+    degraded,
+    stop: () => {
+      stopped = true;
+      offError();
+      offReady();
+    }
+  };
+}
+
+// src/internal/resolveClient.ts
+var import_browser2 = require("@avsbhq/browser");
+var MISUSE_MESSAGE = `[avsb] <AvsbProvider> needs either an sdk-key (Mode A) or a client (Mode B). Mode A: <AvsbProvider sdk-key="sdk_production_..." :context="{ kind: 'user', key: userId }">. Mode B: <AvsbProvider :client="myClient">. The key for each environment is on app.avsb.cloud under Environments in the project sidebar.`;
+function resolveClient(props) {
+  const injected = props.client;
+  if (injected !== void 0 && injected !== null) {
+    return { client: injected, owned: false };
+  }
+  const { sdkKey, context, bootstrap, options } = props;
+  if (typeof sdkKey !== "string" || sdkKey.length === 0) {
+    throw new Error(MISUSE_MESSAGE);
+  }
+  const clientOptions = {
+    ...options ?? {},
+    sdkKey,
+    ...context !== void 0 ? { context } : {},
+    ...bootstrap !== void 0 ? { bootstrap } : {}
+  };
+  return { client: new import_browser2.AvsbClient(clientOptions), owned: true };
+}
+
+// src/AvsbProvider.ts
+var NESTED_PROVIDER_WARNING = "[avsb] <AvsbProvider> is nested inside another <AvsbProvider>. The inner one shadows the outer for everything below it, so two clients are now running, each with its own visitor id and its own event queue. Mount one provider at the root of the app unless you meant to isolate a subtree.";
+var AvsbProvider = (0, import_vue3.defineComponent)({
+  name: "AvsbProvider",
+  props: {
+    /** Mode B: a client you built and own. */
+    client: {
+      type: Object,
+      default: void 0
+    },
+    /** Mode A: the environment's SDK key. */
+    sdkKey: {
+      type: String,
+      default: void 0
+    },
+    /** Mode A: evaluation context. Omit for an anonymous visitor. */
+    context: {
+      type: Object,
+      default: void 0
+    },
+    /** Mode A: a datafile fetched on the server, for a real first paint. */
+    bootstrap: {
+      type: Object,
+      default: void 0
+    },
+    /** Mode A: everything else AvsbClient accepts. */
+    options: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    if (hasAvsbContext() && (0, import_browser3.isDevEnvironment)()) {
+      (0, import_core.consoleLogger)("warn").warn(NESTED_PROVIDER_WARNING);
+    }
+    const { client, owned } = resolveClient(props);
+    const state = createProviderState(client);
+    (0, import_vue3.provide)(AvsbInjectionKey, {
+      client,
+      get status() {
+        return state.status.value;
+      },
+      get error() {
+        return state.error.value;
+      },
+      get degraded() {
+        return state.degraded.value;
+      }
+    });
+    (0, import_vue3.onUnmounted)(() => {
+      state.stop();
+      if (owned) void client.close();
+    });
+    return () => slots.default?.();
+  }
+});
+
+// src/testing.ts
+var AvsbTestProvider = (0, import_vue4.defineComponent)({
+  name: "AvsbTestProvider",
+  props: {
+    flags: {
+      type: Object,
+      default: void 0
+    },
+    context: {
+      type: Object,
+      default: void 0
+    },
+    client: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    const client = props.client ?? createTestClient({
+      ...props.flags !== void 0 ? { flags: props.flags } : {},
+      ...props.context !== void 0 ? { context: props.context } : {}
+    });
+    return () => (0, import_vue4.h)(AvsbProvider, { client }, { default: () => slots.default?.() });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AvsbTestProvider,
+  createTestClient,
+  createTestDatafile
+});

package/dist/testing.d.cts

@@ -0,0 +1,50 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import { TestFlags } from '@avsbhq/test/fixtures';
+export { CreateTestDatafileOptions, TestClientOptions, TestFlagValue, TestFlags, createTestClient, createTestDatafile } from '@avsbhq/test/fixtures';
+import { EvalContext } from '@avsbhq/core';
+import { V as VueAvsbClient } from './clientInterface-BMlQ7Uhe.cjs';
+import '@avsbhq/browser';
+
+/**
+ * `<AvsbTestProvider :flags="{ 'checkout-v2': true }">` mounts the real
+ * provider around a real client, so the components under test use the
+ * composables they use in production.
+ *
+ * Pass `client` instead of `flags` to drive the client yourself.
+ */
+declare const AvsbTestProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    flags: {
+        type: PropType<TestFlags>;
+        default: undefined;
+    };
+    context: {
+        type: PropType<EvalContext>;
+        default: undefined;
+    };
+    client: {
+        type: PropType<VueAvsbClient>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    flags: {
+        type: PropType<TestFlags>;
+        default: undefined;
+    };
+    context: {
+        type: PropType<EvalContext>;
+        default: undefined;
+    };
+    client: {
+        type: PropType<VueAvsbClient>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    flags: TestFlags;
+    context: EvalContext;
+    client: VueAvsbClient;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { AvsbTestProvider };

package/dist/testing.d.ts

@@ -0,0 +1,50 @@
+import * as vue from 'vue';
+import { PropType } from 'vue';
+import { TestFlags } from '@avsbhq/test/fixtures';
+export { CreateTestDatafileOptions, TestClientOptions, TestFlagValue, TestFlags, createTestClient, createTestDatafile } from '@avsbhq/test/fixtures';
+import { EvalContext } from '@avsbhq/core';
+import { V as VueAvsbClient } from './clientInterface-BMlQ7Uhe.js';
+import '@avsbhq/browser';
+
+/**
+ * `<AvsbTestProvider :flags="{ 'checkout-v2': true }">` mounts the real
+ * provider around a real client, so the components under test use the
+ * composables they use in production.
+ *
+ * Pass `client` instead of `flags` to drive the client yourself.
+ */
+declare const AvsbTestProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    flags: {
+        type: PropType<TestFlags>;
+        default: undefined;
+    };
+    context: {
+        type: PropType<EvalContext>;
+        default: undefined;
+    };
+    client: {
+        type: PropType<VueAvsbClient>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    flags: {
+        type: PropType<TestFlags>;
+        default: undefined;
+    };
+    context: {
+        type: PropType<EvalContext>;
+        default: undefined;
+    };
+    client: {
+        type: PropType<VueAvsbClient>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    flags: TestFlags;
+    context: EvalContext;
+    client: VueAvsbClient;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { AvsbTestProvider };

package/dist/testing.js

@@ -0,0 +1,120 @@
+import {
+  AvsbProvider
+} from "./chunk-FUADAPSW.js";
+import "./chunk-4XBADQFO.js";
+
+// src/testing.ts
+import { defineComponent, h } from "vue";
+
+// ../avsb-test/dist/fixtures.js
+import { AvsbClient } from "@avsbhq/browser";
+var TEST_SDK_KEY = "sdk_test_0000000000000000000";
+function flagType(value) {
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  return "json";
+}
+function entryFor(key, value, index) {
+  const variationId = `var_${index}`;
+  return {
+    id: `flag_${index}`,
+    key,
+    type: flagType(value),
+    enabled: true,
+    defaultVariationId: variationId,
+    variations: [{ id: variationId, key: "test", value }],
+    overrides: [],
+    rules: [
+      {
+        id: `rule_${index}`,
+        type: "ab_test",
+        enabled: true,
+        audienceIds: [],
+        hashAttribute: "user.key",
+        trafficAllocation: null,
+        // `percentage` is a 0..1 proportion (the evaluator multiplies it by
+        // 10000), so this is the whole audience.
+        variations: [{ variationId, percentage: 1 }]
+      }
+    ]
+  };
+}
+function createTestDatafile(flags, options) {
+  const mapped = Object.entries(flags ?? {}).map(
+    ([key, value], index) => entryFor(key, value, index)
+  );
+  return {
+    version: 2,
+    projectType: "FEATURE_FLAG",
+    sdkKey: options?.sdkKey ?? TEST_SDK_KEY,
+    environmentKey: options?.environmentKey ?? "test",
+    publishedAt: options?.publishedAt ?? "2024-01-01T00:00:00.000Z",
+    // An ORIGIN, the way the publisher writes it: SDKs append the
+    // `/v1/collect/*` paths themselves through the core endpoint contract.
+    // The `.invalid` TLD is reserved and never resolves, so a stray flush in
+    // a test cannot reach a real host.
+    collectEndpoint: "https://collect.test.invalid",
+    flags: [...mapped, ...options?.entries ?? []],
+    audiences: [],
+    holdouts: [],
+    bandits: [],
+    // `bigSegments` deliberately absent: the field was deleted from the
+    // datafile type (breaking change B28) because nothing evaluated it.
+    contextKinds: ["user"],
+    exposureSampling: 1
+  };
+}
+var TEST_CONTEXT = { kind: "user", key: "test-user" };
+function createTestClient(options) {
+  const datafile = options?.datafile ?? createTestDatafile(options?.flags ?? {});
+  const client = new AvsbClient({
+    sdkKey: datafile.sdkKey || TEST_SDK_KEY,
+    context: options?.context ?? TEST_CONTEXT,
+    // No fetch at construction. The datafile arrives through the bootstrap
+    // handoff below, which is also what wires the tracker and settles
+    // `getInitResult()`, so `track` and `flush` behave as they do in
+    // production instead of queueing forever behind a tracker that a
+    // failed background fetch never created.
+    autoInit: false,
+    autoRefresh: false,
+    cache: false,
+    logLevel: "silent",
+    // Long enough that the automatic flush never fires mid-test. Assert on
+    // events with an explicit `await client.flush()`.
+    events: { flushInterval: 6e4 }
+  });
+  client.applyDatafileBootstrap(datafile);
+  return client;
+}
+
+// src/testing.ts
+var AvsbTestProvider = defineComponent({
+  name: "AvsbTestProvider",
+  props: {
+    flags: {
+      type: Object,
+      default: void 0
+    },
+    context: {
+      type: Object,
+      default: void 0
+    },
+    client: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    const client = props.client ?? createTestClient({
+      ...props.flags !== void 0 ? { flags: props.flags } : {},
+      ...props.context !== void 0 ? { context: props.context } : {}
+    });
+    return () => h(AvsbProvider, { client }, { default: () => slots.default?.() });
+  }
+});
+export {
+  AvsbTestProvider,
+  createTestClient,
+  createTestDatafile
+};