@wow-two-beta/ui-vue 0.0.2

package/dist/flags/FlagProvider.d.ts

@@ -0,0 +1,38 @@
+import { EvaluationContext, FlagErrorCode, FlagReason, FlagValue, JsonObject } from './FlagTypes';
+/** Defines what a provider hands back for one flag — the spec's "resolution details". */
+export interface FlagResolution<TValue extends FlagValue> {
+    /** The resolved value. Re-checked at runtime by the client; a wrong type falls back to the caller's default with `reason: 'error'`. */
+    readonly value: TValue;
+    /** Why this value was produced. Defaults to `static` when omitted; report `targeting` when a rule matched, `disabled` to gate the flag off. */
+    readonly reason?: FlagReason;
+    /** The name of the matched variant — surfaced on the evaluation for analytics/exposure logging. */
+    readonly variant?: string;
+    /** A non-throwing failure channel — set it and the client falls back to the caller's default with `reason: 'error'` and reports to `onError`. */
+    readonly errorCode?: FlagErrorCode;
+    /** A human-readable description accompanying `errorCode`. */
+    readonly errorMessage?: string;
+}
+/**
+ * Defines the flag source behind a {@link FlagClient}. Return `undefined` from a `resolve*` to say
+ * "this flag is not configured" — the client then uses the caller's `defaultValue` with
+ * `reason: 'default'`, no error reported. Throwing is allowed but not required: the client catches
+ * every throw, falls back, and routes it to `onError`.
+ */
+export interface FlagProvider {
+    /** An optional name for diagnostics / logs (`'static'`, `'launchdarkly'`). */
+    readonly name?: string;
+    /** Resolves a boolean flag; `undefined` when the flag is not configured. */
+    resolveBoolean(key: string, context: EvaluationContext): FlagResolution<boolean> | undefined;
+    /** Resolves a string flag; `undefined` when the flag is not configured. */
+    resolveString(key: string, context: EvaluationContext): FlagResolution<string> | undefined;
+    /** Resolves a number flag; `undefined` when the flag is not configured. */
+    resolveNumber(key: string, context: EvaluationContext): FlagResolution<number> | undefined;
+    /** Resolves a JSON object flag; `undefined` when the flag is not configured. */
+    resolveObject(key: string, context: EvaluationContext): FlagResolution<JsonObject> | undefined;
+    /**
+     * Fires after the client's evaluation context changes — where a remote adapter refetches its
+     * snapshot for the new targeting subject. A returned promise is awaited only to catch rejection
+     * (routed to `onError`); evaluation never blocks on it.
+     */
+    onContextChange?(context: EvaluationContext): void | Promise<void>;
+}

package/dist/flags/FlagTypes.d.ts

@@ -0,0 +1,85 @@
+/** Defines a JSON scalar — the leaves of an object flag's payload. */
+export type JsonPrimitive = string | number | boolean | null;
+/** Defines any JSON-serialisable value inside an object flag's payload. */
+export type JsonValue = JsonPrimitive | readonly JsonValue[] | JsonObject;
+/**
+ * Defines the payload of an object flag — a JSON object.
+ *
+ * TS only grants *type aliases* an implicit index signature, so a payload typed by an `interface`
+ * is not assignable here; declare the payload with `type Payload = { … }` (or extend `JsonObject`).
+ */
+export interface JsonObject {
+    /** The payload entries — any JSON-serialisable value. */
+    readonly [key: string]: JsonValue;
+}
+/** Defines every value a flag can evaluate to — the four supported flag types. */
+export type FlagValue = boolean | string | number | JsonObject;
+/** Defines an attribute value carried by an {@link EvaluationContext} — comparable scalars, plus a list for multi-value attributes (roles, groups). */
+export type ContextAttribute = string | number | boolean | null | readonly (string | number | boolean)[];
+/**
+ * Defines the targeting input of an evaluation — who/what the flag is being resolved for.
+ * `targetingKey` is the spec's stable subject identity (user id, tenant, device); every other
+ * attribute is free-form and matched by a provider's rules.
+ *
+ * Set app-wide with `client.setContext(…)` (merged, see {@link FlagClient}) and override per call
+ * by passing a context to any `get*` / `evaluate*`.
+ */
+export interface EvaluationContext {
+    /** The stable identity the flag is resolved for — user id, tenant id, device id. */
+    readonly targetingKey?: string;
+    /** Any further targeting attribute — `plan`, `region`, `roles`, `isInternal`. */
+    readonly [attribute: string]: ContextAttribute | undefined;
+}
+/** Defines why an evaluation produced the value it did. */
+export declare const FlagReason: {
+    /** Refers to the flag's configured value, with no rule involved. */
+    readonly Static: "static";
+    /** Refers to a value chosen by a targeting rule matching the evaluation context. */
+    readonly Targeting: "targeting";
+    /** Refers to the caller's `defaultValue` standing in because the flag is not configured — the normal pre-rollout state, not a fault. */
+    readonly Default: "default";
+    /** Refers to the caller's `defaultValue` standing in after a fault (wrong type on the wire, throwing provider) — see `errorCode`. */
+    readonly Error: "error";
+    /** Refers to the caller's `defaultValue` standing in because the flag exists but is switched off. */
+    readonly Disabled: "disabled";
+};
+export type FlagReason = (typeof FlagReason)[keyof typeof FlagReason];
+/** Defines what went wrong on an evaluation with `reason: 'error'`. */
+export declare const FlagErrorCode: {
+    /** Refers to a resolved value whose runtime type is not the type asked for (a `string` for `getBoolean`, a non-finite `number`, an array for an object flag). */
+    readonly TypeMismatch: "type-mismatch";
+    /** Refers to a provider that threw, rejected, or reported its own failure. */
+    readonly ProviderError: "provider-error";
+    /** Refers to a `defaultValue` that is not one of the four supported flag types — reachable only from untyped JS. */
+    readonly InvalidDefault: "invalid-default";
+};
+export type FlagErrorCode = (typeof FlagErrorCode)[keyof typeof FlagErrorCode];
+/**
+ * Defines the full outcome of one evaluation. Always carries a usable `value`: on any miss,
+ * mismatch, or provider fault it is the caller's `defaultValue`, and `reason` says which.
+ */
+export interface FlagEvaluation<TValue extends FlagValue> {
+    /** The flag key evaluated. */
+    readonly key: string;
+    /** The resolved value, or the caller's `defaultValue` when `reason` is `default` / `error` / `disabled`. */
+    readonly value: TValue;
+    /** Why this value was produced. */
+    readonly reason: FlagReason;
+    /** The name of the matched variant, when the provider reports one — for analytics/exposure logging. */
+    readonly variant?: string;
+    /** What went wrong; set only when `reason` is `error`. */
+    readonly errorCode?: FlagErrorCode;
+    /** A human-readable description of the fault; set only when `reason` is `error`. */
+    readonly errorMessage?: string;
+}
+/** Defines the fault handed to `createFlagClient({ onError })` — evaluation itself has already fallen back, this is the reporting channel. */
+export interface FlagErrorInfo {
+    /** The flag key being evaluated when the fault occurred. */
+    readonly key: string;
+    /** What went wrong. */
+    readonly errorCode: FlagErrorCode;
+    /** A human-readable description of the fault. */
+    readonly message: string;
+    /** The original thrown value, when the fault came from a throwing/rejecting provider. */
+    readonly cause?: unknown;
+}

package/dist/flags/FlagsContext.d.ts

@@ -0,0 +1,32 @@
+import { ComputedRef, MaybeRefOrGetter } from 'vue';
+import { FlagClient } from './FlagClient';
+import { FlagValue } from './FlagTypes';
+/**
+ * The provider half — used by `FlagsProvider`, and by any component that owns a flag client.
+ * Subscribes to the client and re-subscribes if the active client is swapped, disposing the previous
+ * subscription through the watcher's `onCleanup`.
+ *
+ * Pass `client` as a getter (`() => props.client ?? ownClient`) so the active client stays tracked.
+ */
+export declare function provideFlags(client: MaybeRefOrGetter<FlagClient>): void;
+/**
+ * Reads the flag client. Works without a {@link FlagsProvider} — falls back to an empty one, where
+ * every flag returns the caller's default.
+ *
+ * Returns the plain `FlagClient` rather than a ref, matching the React original: the client is
+ * created once and never re-created, so there is nothing to track. Use it for imperative reads and
+ * for `setContext`; for a value that must re-evaluate when the evaluation context moves, use
+ * {@link useFlag}, whose computed is the reactive path.
+ */
+export declare function useFlags(): FlagClient;
+/**
+ * Reads one flag's value, re-evaluating whenever the evaluation context changes. The typed path is
+ * picked from `defaultValue`, which also types the result — `useFlag('newNav', false)` is
+ * `ComputedRef<boolean>`, `useFlag('limits', { max: 10 })` is a computed of that object type.
+ *
+ * Diverges from the React original, which returned a bare `TValue` re-read on every render: this
+ * returns a `ComputedRef<TValue>`, because a bare value could never re-evaluate. `key` and
+ * `defaultValue` may each be a ref or getter — changing either re-evaluates the flag, which the
+ * React signature could not express at all.
+ */
+export declare function useFlag<TValue extends FlagValue>(key: MaybeRefOrGetter<string>, defaultValue: MaybeRefOrGetter<TValue>): ComputedRef<TValue>;

package/dist/flags/FlagsProvider.vue.d.ts

@@ -0,0 +1,24 @@
+import { FlagClient, FlagErrorListener } from './FlagClient';
+import { FlagProvider } from './FlagProvider';
+import { EvaluationContext } from './FlagTypes';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines the props for {@link FlagsProvider}. */
+export interface FlagsProviderProps {
+    /** An existing client to serve — the app-wide instance shared with non-Vue callers. Takes precedence over `provider` / `onError`. */
+    client?: FlagClient;
+    /** The flag source to build a client around, when no `client` is passed. Read once, at setup. */
+    provider?: FlagProvider;
+    /** The evaluation context. Kept in sync on every change — a fresh object literal per render is safe. */
+    context?: EvaluationContext;
+    /** Receives evaluation faults, when no `client` is passed. Read once, at setup. */
+    onError?: FlagErrorListener;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<FlagsProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<FlagsProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/flags/StaticFlagProvider.d.ts

@@ -0,0 +1,51 @@
+import { FlagProvider } from './FlagProvider';
+import { ContextAttribute, EvaluationContext, FlagValue, JsonObject } from './FlagTypes';
+/**
+ * Defines a targeting condition. Either an attribute map — every entry must match, an array value
+ * meaning "is one of" — or a predicate for anything more involved.
+ *
+ * `{ plan: 'pro' }` · `{ plan: ['pro', 'team'], region: 'eu' }` · `(ctx) => ctx.seats > 50`
+ */
+export type StaticFlagCondition = Readonly<Record<string, ContextAttribute | readonly ContextAttribute[]>> | ((context: EvaluationContext) => boolean);
+/** Defines one targeting rule of a static flag — the value served to contexts matching `when`. */
+export interface StaticFlagRule<TValue extends FlagValue> {
+    /** The condition the evaluation context must satisfy. */
+    readonly when: StaticFlagCondition;
+    /** The value served on a match — reported with `reason: 'targeting'`. */
+    readonly value: TValue;
+    /** The variant name reported on a match; falls back to the definition's `variant`. */
+    readonly variant?: string;
+}
+/** Defines a static flag with variants, targeting, or an off switch — the long form of a map entry. */
+export interface StaticFlagDefinition<TValue extends FlagValue> {
+    /** The value served when no rule matches — reported with `reason: 'static'`. */
+    readonly value: TValue;
+    /** The variant name reported alongside `value`. */
+    readonly variant?: string;
+    /** Whether the flag is switched off — every evaluation returns the CALLER's default with `reason: 'disabled'`, rules skipped. */
+    readonly disabled?: boolean;
+    /** The targeting rules, evaluated top-down; the first match wins. */
+    readonly rules?: readonly StaticFlagRule<TValue>[];
+}
+/**
+ * Defines one entry of a static flag map — a bare value or a {@link StaticFlagDefinition}.
+ *
+ * The two are told apart by the presence of a `value` property, so an object flag whose payload
+ * itself has a `value` key must use the long form (`{ value: { value: 1 } }`).
+ */
+export type StaticFlagEntry = boolean | string | number | JsonObject | StaticFlagDefinition<FlagValue>;
+/** Defines the `key → flag` map backing a {@link staticFlagProvider}. */
+export type StaticFlags = Readonly<Record<string, StaticFlagEntry>>;
+/**
+ * Creates an in-memory {@link FlagProvider} over a `key → flag` map — the test double, the
+ * local-dev default, and the fallback used when a client is created without a provider.
+ *
+ * ```ts
+ * const provider = staticFlagProvider({
+ *   newNav: true,                                        // bare value
+ *   theme: { value: 'light', variant: 'control', rules: [{ when: { plan: ['pro', 'team'] }, value: 'dark', variant: 'treatment' }] },
+ *   legacyExport: { value: true, disabled: true },        // gated off → callers get their own default
+ * });
+ * ```
+ */
+export declare function staticFlagProvider(flags?: StaticFlags): FlagProvider;

package/dist/flags/index.d.ts

@@ -0,0 +1,6 @@
+export { FlagReason, FlagErrorCode, type JsonPrimitive, type JsonValue, type JsonObject, type FlagValue, type ContextAttribute, type EvaluationContext, type FlagEvaluation, type FlagErrorInfo, } from './FlagTypes';
+export type { FlagProvider, FlagResolution } from './FlagProvider';
+export { staticFlagProvider, type StaticFlags, type StaticFlagEntry, type StaticFlagDefinition, type StaticFlagRule, type StaticFlagCondition, } from './StaticFlagProvider';
+export { createFlagClient, type FlagClient, type CreateFlagClientOptions, type FlagErrorListener, type FlagContextListener, } from './FlagClient';
+export { default as FlagsProvider, type FlagsProviderProps } from './FlagsProvider.vue';
+export { useFlag, useFlags } from './FlagsContext';

package/dist/flags/index.js

@@ -0,0 +1,243 @@
+import { computed, toValue, ref, watch, provide, inject, defineComponent, renderSlot } from "vue";
+const FlagReason = {
+  /** Refers to the flag's configured value, with no rule involved. */
+  Static: "static",
+  /** Refers to a value chosen by a targeting rule matching the evaluation context. */
+  Targeting: "targeting",
+  /** Refers to the caller's `defaultValue` standing in because the flag is not configured — the normal pre-rollout state, not a fault. */
+  Default: "default",
+  /** Refers to the caller's `defaultValue` standing in after a fault (wrong type on the wire, throwing provider) — see `errorCode`. */
+  Error: "error",
+  /** Refers to the caller's `defaultValue` standing in because the flag exists but is switched off. */
+  Disabled: "disabled"
+};
+const FlagErrorCode = {
+  /** Refers to a resolved value whose runtime type is not the type asked for (a `string` for `getBoolean`, a non-finite `number`, an array for an object flag). */
+  TypeMismatch: "type-mismatch",
+  /** Refers to a provider that threw, rejected, or reported its own failure. */
+  ProviderError: "provider-error",
+  /** Refers to a `defaultValue` that is not one of the four supported flag types — reachable only from untyped JS. */
+  InvalidDefault: "invalid-default"
+};
+function attributeMatches(actual, expected) {
+  if (Array.isArray(expected)) {
+    return expected.some((candidate) => attributeMatches(actual, candidate));
+  }
+  if (Array.isArray(actual)) {
+    return actual.some((entry) => entry === expected);
+  }
+  return actual === expected;
+}
+function conditionMatches(condition, context) {
+  if (typeof condition === "function") return condition(context);
+  return Object.entries(condition).every(([attribute, expected]) => attributeMatches(context[attribute], expected));
+}
+function isDefinition(entry) {
+  return typeof entry === "object" && entry !== null && !Array.isArray(entry) && "value" in entry;
+}
+function staticFlagProvider(flags = {}) {
+  const resolve = (key, context) => {
+    const entry = flags[key];
+    if (entry === void 0) return void 0;
+    const definition = isDefinition(entry) ? entry : { value: entry };
+    if (definition.disabled === true) {
+      return { value: definition.value, reason: FlagReason.Disabled, variant: definition.variant };
+    }
+    for (const rule of definition.rules ?? []) {
+      if (conditionMatches(rule.when, context)) {
+        return { value: rule.value, reason: FlagReason.Targeting, variant: rule.variant ?? definition.variant };
+      }
+    }
+    return { value: definition.value, reason: FlagReason.Static, variant: definition.variant };
+  };
+  return {
+    name: "static",
+    resolveBoolean: (key, context) => resolve(key, context),
+    resolveString: (key, context) => resolve(key, context),
+    resolveNumber: (key, context) => resolve(key, context),
+    resolveObject: (key, context) => resolve(key, context)
+  };
+}
+function attributesEqual(left, right) {
+  if (Array.isArray(left) && Array.isArray(right)) {
+    const rightEntries = right;
+    const leftEntries = left;
+    return leftEntries.length === rightEntries.length && leftEntries.every((entry, index) => entry === rightEntries[index]);
+  }
+  return left === right;
+}
+function contextsEqual(left, right) {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  return leftKeys.length === rightKeys.length && leftKeys.every((key) => attributesEqual(left[key], right[key]));
+}
+function mergeContext(base, patch) {
+  const merged = { ...base, ...patch };
+  for (const key of Object.keys(merged)) {
+    if (merged[key] === void 0) delete merged[key];
+  }
+  return merged;
+}
+function createFlagClient(options = {}) {
+  const provider = options.provider ?? staticFlagProvider();
+  const onError = options.onError;
+  const listeners = /* @__PURE__ */ new Set();
+  let currentContext = options.context ? mergeContext({}, options.context) : {};
+  const report = (key, errorCode, message, cause) => {
+    onError?.({ key, errorCode, message, cause });
+  };
+  const core = (key, defaultValue, callerContext, resolve, isValid, typeName) => {
+    const context = callerContext ? mergeContext(currentContext, callerContext) : currentContext;
+    let resolution;
+    try {
+      resolution = resolve(key, context);
+    } catch (cause) {
+      const message = `provider "${provider.name ?? "unnamed"}" threw while resolving "${key}"`;
+      report(key, FlagErrorCode.ProviderError, message, cause);
+      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.ProviderError, errorMessage: message };
+    }
+    if (resolution === void 0) return { key, value: defaultValue, reason: FlagReason.Default };
+    if (resolution.errorCode !== void 0) {
+      const message = resolution.errorMessage ?? `provider reported "${resolution.errorCode}" for "${key}"`;
+      report(key, resolution.errorCode, message);
+      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: resolution.errorCode, errorMessage: message, variant: resolution.variant };
+    }
+    if (resolution.reason === FlagReason.Disabled) {
+      return { key, value: defaultValue, reason: FlagReason.Disabled, variant: resolution.variant };
+    }
+    if (!isValid(resolution.value)) {
+      const message = `flag "${key}" resolved to ${typeof resolution.value}, expected ${typeName}`;
+      report(key, FlagErrorCode.TypeMismatch, message);
+      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.TypeMismatch, errorMessage: message, variant: resolution.variant };
+    }
+    return { key, value: resolution.value, reason: resolution.reason ?? FlagReason.Static, variant: resolution.variant };
+  };
+  const isBoolean = (value) => typeof value === "boolean";
+  const isString = (value) => typeof value === "string";
+  const isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+  const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const evaluateBoolean = (key, defaultValue, context) => core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, "boolean");
+  const evaluateString = (key, defaultValue, context) => core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, "string");
+  const evaluateNumber = (key, defaultValue, context) => core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, "number");
+  const evaluateObject = (key, defaultValue, context) => core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, "object");
+  const evaluate = (key, defaultValue, context) => {
+    if (typeof defaultValue === "boolean") return core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, "boolean");
+    if (typeof defaultValue === "string") return core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, "string");
+    if (typeof defaultValue === "number") return core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, "number");
+    if (isJsonObject(defaultValue)) return core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, "object");
+    const message = `flag "${key}" was given a ${typeof defaultValue} default, expected boolean, string, number, or object`;
+    report(key, FlagErrorCode.InvalidDefault, message);
+    return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.InvalidDefault, errorMessage: message };
+  };
+  const notifyProvider = (context) => {
+    const hook = provider.onContextChange;
+    if (hook === void 0) return;
+    const fail = (cause) => report("", FlagErrorCode.ProviderError, `provider "${provider.name ?? "unnamed"}" failed handling the context change`, cause);
+    try {
+      const pending = hook.call(provider, context);
+      if (pending instanceof Promise) void pending.catch(fail);
+    } catch (cause) {
+      fail(cause);
+    }
+  };
+  return {
+    provider,
+    getBoolean: (key, defaultValue, context) => evaluateBoolean(key, defaultValue, context).value,
+    getString: (key, defaultValue, context) => evaluateString(key, defaultValue, context).value,
+    getNumber: (key, defaultValue, context) => evaluateNumber(key, defaultValue, context).value,
+    // Generic method shorthand, not an arrow: a non-generic arrow contextually typed by a generic
+    // signature widens `TValue` to its constraint and the return no longer narrows back.
+    getObject(key, defaultValue, context) {
+      return evaluateObject(key, defaultValue, context).value;
+    },
+    evaluateBoolean,
+    evaluateString,
+    evaluateNumber,
+    evaluateObject,
+    getValue(key, defaultValue, context) {
+      return evaluate(key, defaultValue, context).value;
+    },
+    evaluate,
+    getContext: () => currentContext,
+    setContext(context) {
+      const next = mergeContext(currentContext, context);
+      if (contextsEqual(currentContext, next)) return;
+      currentContext = next;
+      notifyProvider(next);
+      for (const listener of [...listeners]) listener(next);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+const FlagsKey = Symbol("wow-two.flags");
+let standalone;
+function standaloneContext() {
+  if (!standalone) {
+    const client = createFlagClient();
+    standalone = { client: computed(() => client), revision: ref(0) };
+  }
+  return standalone;
+}
+function provideFlags(client) {
+  const active = computed(() => toValue(client));
+  const revision = ref(0);
+  watch(
+    active,
+    (current, _previous, onCleanup) => {
+      onCleanup(current.subscribe(() => revision.value += 1));
+    },
+    { immediate: true }
+  );
+  provide(FlagsKey, { client: active, revision });
+}
+function resolveFlags() {
+  return inject(FlagsKey, standaloneContext, true);
+}
+function useFlags() {
+  return resolveFlags().client.value;
+}
+function useFlag(key, defaultValue) {
+  const { client, revision } = resolveFlags();
+  return computed(() => {
+    void revision.value;
+    return client.value.getValue(toValue(key), toValue(defaultValue));
+  });
+}
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "FlagsProvider" },
+  __name: "FlagsProvider",
+  props: {
+    client: {},
+    provider: {},
+    context: {},
+    onError: { type: Function }
+  },
+  setup(__props) {
+    const props = __props;
+    const ownClient = props.client ?? createFlagClient({ provider: props.provider, context: props.context, onError: props.onError });
+    provideFlags(() => props.client ?? ownClient);
+    watch(
+      [() => props.client ?? ownClient, () => props.context],
+      ([client, context]) => {
+        if (context !== void 0) client.setContext(context);
+      },
+      { immediate: true }
+    );
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+export {
+  FlagErrorCode,
+  FlagReason,
+  _sfc_main as FlagsProvider,
+  createFlagClient,
+  staticFlagProvider,
+  useFlag,
+  useFlags
+};
+//# sourceMappingURL=index.js.map

package/dist/flags/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/flags/FlagTypes.ts","../../src/flags/StaticFlagProvider.ts","../../src/flags/FlagClient.ts","../../src/flags/FlagsContext.ts","../../src/flags/FlagsProvider.vue"],"sourcesContent":["/*\n * OpenFeature-SHAPED vocabulary, mirrored structurally — NO `@openfeature/*` dependency, exactly\n * like `forms-engine/StandardSchema.ts` vendors the Standard Schema spec types. An app that later\n * adopts the real OpenFeature JS SDK re-points its adapter and keeps every call site: evaluation\n * context, resolution details, reason, error code and variant all carry the spec's meaning.\n *\n * Three deliberate divergences, each in service of \"every evaluation is total\" (see FlagClient.ts):\n *   - reasons are lowercase house strings (`'targeting'`, not the spec's `TARGETING_MATCH`), matching\n *     the `AuthStatus` / `NoticeTone` const-object shape used everywhere else in this SDK;\n *   - a MISSING flag is `reason: 'default'`, NOT an error — an unconfigured flag is the normal state\n *     during a rollout, so it carries no `errorCode` and never reaches `onError`. Only a genuine\n *     fault (wrong wire type, throwing provider) is an error;\n *   - object flags are constrained to a JSON *object* (`JsonObject`), not the spec's whole\n *     `JsonValue` — a top-level array or scalar flag is expressed as its own typed flag instead.\n */\n\n/** Defines a JSON scalar — the leaves of an object flag's payload. */\nexport type JsonPrimitive = string | number | boolean | null;\n\n/** Defines any JSON-serialisable value inside an object flag's payload. */\nexport type JsonValue = JsonPrimitive | readonly JsonValue[] | JsonObject;\n\n/**\n * Defines the payload of an object flag — a JSON object.\n *\n * TS only grants *type aliases* an implicit index signature, so a payload typed by an `interface`\n * is not assignable here; declare the payload with `type Payload = { … }` (or extend `JsonObject`).\n */\nexport interface JsonObject {\n  /** The payload entries — any JSON-serialisable value. */\n  readonly [key: string]: JsonValue;\n}\n\n/** Defines every value a flag can evaluate to — the four supported flag types. */\nexport type FlagValue = boolean | string | number | JsonObject;\n\n/** Defines an attribute value carried by an {@link EvaluationContext} — comparable scalars, plus a list for multi-value attributes (roles, groups). */\nexport type ContextAttribute = string | number | boolean | null | readonly (string | number | boolean)[];\n\n/**\n * Defines the targeting input of an evaluation — who/what the flag is being resolved for.\n * `targetingKey` is the spec's stable subject identity (user id, tenant, device); every other\n * attribute is free-form and matched by a provider's rules.\n *\n * Set app-wide with `client.setContext(…)` (merged, see {@link FlagClient}) and override per call\n * by passing a context to any `get*` / `evaluate*`.\n */\nexport interface EvaluationContext {\n  /** The stable identity the flag is resolved for — user id, tenant id, device id. */\n  readonly targetingKey?: string;\n\n  /** Any further targeting attribute — `plan`, `region`, `roles`, `isInternal`. */\n  readonly [attribute: string]: ContextAttribute | undefined;\n}\n\n/** Defines why an evaluation produced the value it did. */\nexport const FlagReason = {\n  /** Refers to the flag's configured value, with no rule involved. */\n  Static: 'static',\n  /** Refers to a value chosen by a targeting rule matching the evaluation context. */\n  Targeting: 'targeting',\n  /** Refers to the caller's `defaultValue` standing in because the flag is not configured — the normal pre-rollout state, not a fault. */\n  Default: 'default',\n  /** Refers to the caller's `defaultValue` standing in after a fault (wrong type on the wire, throwing provider) — see `errorCode`. */\n  Error: 'error',\n  /** Refers to the caller's `defaultValue` standing in because the flag exists but is switched off. */\n  Disabled: 'disabled',\n} as const;\n\nexport type FlagReason = (typeof FlagReason)[keyof typeof FlagReason];\n\n/** Defines what went wrong on an evaluation with `reason: 'error'`. */\nexport const FlagErrorCode = {\n  /** Refers to a resolved value whose runtime type is not the type asked for (a `string` for `getBoolean`, a non-finite `number`, an array for an object flag). */\n  TypeMismatch: 'type-mismatch',\n  /** Refers to a provider that threw, rejected, or reported its own failure. */\n  ProviderError: 'provider-error',\n  /** Refers to a `defaultValue` that is not one of the four supported flag types — reachable only from untyped JS. */\n  InvalidDefault: 'invalid-default',\n} as const;\n\nexport type FlagErrorCode = (typeof FlagErrorCode)[keyof typeof FlagErrorCode];\n\n/**\n * Defines the full outcome of one evaluation. Always carries a usable `value`: on any miss,\n * mismatch, or provider fault it is the caller's `defaultValue`, and `reason` says which.\n */\nexport interface FlagEvaluation<TValue extends FlagValue> {\n  /** The flag key evaluated. */\n  readonly key: string;\n\n  /** The resolved value, or the caller's `defaultValue` when `reason` is `default` / `error` / `disabled`. */\n  readonly value: TValue;\n\n  /** Why this value was produced. */\n  readonly reason: FlagReason;\n\n  /** The name of the matched variant, when the provider reports one — for analytics/exposure logging. */\n  readonly variant?: string;\n\n  /** What went wrong; set only when `reason` is `error`. */\n  readonly errorCode?: FlagErrorCode;\n\n  /** A human-readable description of the fault; set only when `reason` is `error`. */\n  readonly errorMessage?: string;\n}\n\n/** Defines the fault handed to `createFlagClient({ onError })` — evaluation itself has already fallen back, this is the reporting channel. */\nexport interface FlagErrorInfo {\n  /** The flag key being evaluated when the fault occurred. */\n  readonly key: string;\n\n  /** What went wrong. */\n  readonly errorCode: FlagErrorCode;\n\n  /** A human-readable description of the fault. */\n  readonly message: string;\n\n  /** The original thrown value, when the fault came from a throwing/rejecting provider. */\n  readonly cause?: unknown;\n}\n","import type { FlagProvider, FlagResolution } from './FlagProvider';\nimport { FlagReason, type ContextAttribute, type EvaluationContext, type FlagValue, type JsonObject } from './FlagTypes';\n\n/*\n * The in-memory provider: the test double AND the local-dev default (`createFlagClient()` with no\n * provider runs an empty one, so every flag cleanly returns the caller's default).\n *\n * A flag is either a bare value (`{ newNav: true }`) or a definition carrying variants, targeting\n * rules and the disabled gate. Rules are evaluated top-down, first match wins — deliberately no\n * rule algebra: this is a local stand-in for a real flag service's targeting, not a rules engine.\n *\n * NOT VALIDATED ON PURPOSE: the typed `resolve*` methods cast their entry rather than checking it,\n * so a map declaring `{ newNav: 'yes' }` really does hand a string to `getBoolean` — which is what\n * makes this provider a faithful double for the type-mismatch path the client guards.\n */\n\n/**\n * Defines a targeting condition. Either an attribute map — every entry must match, an array value\n * meaning \"is one of\" — or a predicate for anything more involved.\n *\n * `{ plan: 'pro' }` · `{ plan: ['pro', 'team'], region: 'eu' }` · `(ctx) => ctx.seats > 50`\n */\nexport type StaticFlagCondition =\n  | Readonly<Record<string, ContextAttribute | readonly ContextAttribute[]>>\n  | ((context: EvaluationContext) => boolean);\n\n/** Defines one targeting rule of a static flag — the value served to contexts matching `when`. */\nexport interface StaticFlagRule<TValue extends FlagValue> {\n  /** The condition the evaluation context must satisfy. */\n  readonly when: StaticFlagCondition;\n\n  /** The value served on a match — reported with `reason: 'targeting'`. */\n  readonly value: TValue;\n\n  /** The variant name reported on a match; falls back to the definition's `variant`. */\n  readonly variant?: string;\n}\n\n/** Defines a static flag with variants, targeting, or an off switch — the long form of a map entry. */\nexport interface StaticFlagDefinition<TValue extends FlagValue> {\n  /** The value served when no rule matches — reported with `reason: 'static'`. */\n  readonly value: TValue;\n\n  /** The variant name reported alongside `value`. */\n  readonly variant?: string;\n\n  /** Whether the flag is switched off — every evaluation returns the CALLER's default with `reason: 'disabled'`, rules skipped. */\n  readonly disabled?: boolean;\n\n  /** The targeting rules, evaluated top-down; the first match wins. */\n  readonly rules?: readonly StaticFlagRule<TValue>[];\n}\n\n/**\n * Defines one entry of a static flag map — a bare value or a {@link StaticFlagDefinition}.\n *\n * The two are told apart by the presence of a `value` property, so an object flag whose payload\n * itself has a `value` key must use the long form (`{ value: { value: 1 } }`).\n */\nexport type StaticFlagEntry = boolean | string | number | JsonObject | StaticFlagDefinition<FlagValue>;\n\n/** Defines the `key → flag` map backing a {@link staticFlagProvider}. */\nexport type StaticFlags = Readonly<Record<string, StaticFlagEntry>>;\n\n/** Reports whether one context attribute satisfies one expected value — an expected array means \"is one of\", an actual array means \"contains\". */\nfunction attributeMatches(actual: ContextAttribute | undefined, expected: ContextAttribute | readonly ContextAttribute[]): boolean {\n  if (Array.isArray(expected)) {\n    return (expected as readonly ContextAttribute[]).some((candidate) => attributeMatches(actual, candidate));\n  }\n  if (Array.isArray(actual)) {\n    return (actual as readonly (string | number | boolean)[]).some((entry) => entry === expected);\n  }\n  return actual === expected;\n}\n\n/** Reports whether an evaluation context satisfies a condition — every attribute must match, or the predicate must return `true`. */\nfunction conditionMatches(condition: StaticFlagCondition, context: EvaluationContext): boolean {\n  if (typeof condition === 'function') return condition(context);\n  return Object.entries(condition).every(([attribute, expected]) => attributeMatches(context[attribute], expected));\n}\n\n/** Reports whether a map entry is the long form — an object carrying a `value` property. */\nfunction isDefinition(entry: StaticFlagEntry): entry is StaticFlagDefinition<FlagValue> {\n  return typeof entry === 'object' && entry !== null && !Array.isArray(entry) && 'value' in entry;\n}\n\n/**\n * Creates an in-memory {@link FlagProvider} over a `key → flag` map — the test double, the\n * local-dev default, and the fallback used when a client is created without a provider.\n *\n * ```ts\n * const provider = staticFlagProvider({\n *   newNav: true,                                        // bare value\n *   theme: { value: 'light', variant: 'control', rules: [{ when: { plan: ['pro', 'team'] }, value: 'dark', variant: 'treatment' }] },\n *   legacyExport: { value: true, disabled: true },        // gated off → callers get their own default\n * });\n * ```\n */\nexport function staticFlagProvider(flags: StaticFlags = {}): FlagProvider {\n  const resolve = (key: string, context: EvaluationContext): FlagResolution<FlagValue> | undefined => {\n    const entry = flags[key];\n    if (entry === undefined) return undefined; // not configured — the client uses the caller's default\n\n    const definition: StaticFlagDefinition<FlagValue> = isDefinition(entry) ? entry : { value: entry };\n    if (definition.disabled === true) {\n      return { value: definition.value, reason: FlagReason.Disabled, variant: definition.variant };\n    }\n\n    for (const rule of definition.rules ?? []) {\n      if (conditionMatches(rule.when, context)) {\n        return { value: rule.value, reason: FlagReason.Targeting, variant: rule.variant ?? definition.variant };\n      }\n    }\n\n    return { value: definition.value, reason: FlagReason.Static, variant: definition.variant };\n  };\n\n  // Each typed method casts rather than validates — a mistyped map must reach the client's\n  // runtime type check, which is the behaviour under test.\n  return {\n    name: 'static',\n    resolveBoolean: (key, context) => resolve(key, context) as FlagResolution<boolean> | undefined,\n    resolveString: (key, context) => resolve(key, context) as FlagResolution<string> | undefined,\n    resolveNumber: (key, context) => resolve(key, context) as FlagResolution<number> | undefined,\n    resolveObject: (key, context) => resolve(key, context) as FlagResolution<JsonObject> | undefined,\n  };\n}\n","import type { FlagProvider, FlagResolution } from './FlagProvider';\nimport { staticFlagProvider } from './StaticFlagProvider';\nimport {\n  FlagErrorCode,\n  FlagReason,\n  type ContextAttribute,\n  type EvaluationContext,\n  type FlagErrorInfo,\n  type FlagEvaluation,\n  type FlagValue,\n  type JsonObject,\n} from './FlagTypes';\n\n/*\n * The evaluator. One rule governs the whole file: EVERY EVALUATION IS TOTAL — it returns a value of\n * the type asked for and never throws, whatever the provider does. A flag read sits inside render\n * paths and hot code; a throwing flag read would take a screen down over a config typo, which is the\n * opposite of what a kill-switch is for. So every failure mode lands on the caller's `defaultValue`:\n *\n *   not configured        → reason 'default'   (no errorCode, NOT reported — normal during rollout)\n *   flag switched off     → reason 'disabled'  (no errorCode, not reported)\n *   wrong runtime type    → reason 'error'     errorCode 'type-mismatch'   → onError\n *   provider threw/failed → reason 'error'     errorCode 'provider-error'  → onError\n *\n * `onError` is therefore the ONLY channel that surfaces a fault — wire it to the feedback bus or a\n * logger. It is called outside a try/catch on purpose (as the feedback bus calls its listeners): a\n * throwing app callback is an app bug and must not be swallowed here.\n *\n * The runtime type check is not belt-and-braces over TypeScript — the provider's typed `resolve*`\n * signatures describe an untyped wire payload, so the check is the only thing that actually holds.\n * `number` additionally rejects `NaN` / `Infinity`: neither survives a JSON round-trip intact, so\n * either one means the payload is broken, not that the flag is set to a strange number.\n */\n\n/** Defines the listener handed each evaluation fault — the reporting channel, evaluation has already fallen back. */\nexport type FlagErrorListener = (error: FlagErrorInfo) => void;\n\n/** Defines the listener notified after the evaluation context changes — how the Vue seam knows to re-evaluate. */\nexport type FlagContextListener = (context: EvaluationContext) => void;\n\n/** Defines the options for {@link createFlagClient}. */\nexport interface CreateFlagClientOptions {\n  /** The flag source. Defaults to an empty {@link staticFlagProvider} — every flag returns the caller's default. */\n  readonly provider?: FlagProvider;\n\n  /** The initial evaluation context (targeting subject + attributes). */\n  readonly context?: EvaluationContext;\n\n  /** Receives every evaluation fault (type mismatch, provider error). Misses and disabled flags are not faults and never arrive here. */\n  readonly onError?: FlagErrorListener;\n}\n\n/**\n * Defines the app-facing evaluation API. `get*` returns just the value — the everyday call; `evaluate*`\n * returns the full {@link FlagEvaluation} when the reason or variant matters (exposure logging,\n * debugging a rollout). Both are total: on any miss or fault the caller's `defaultValue` comes back.\n *\n * Each call takes an optional context that is merged over the client-wide one for that call only.\n */\nexport interface FlagClient {\n  /** The flag source behind this client. */\n  readonly provider: FlagProvider;\n\n  /** Evaluates a boolean flag, returning its value. */\n  getBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): boolean;\n\n  /** Evaluates a string flag, returning its value. */\n  getString(key: string, defaultValue: string, context?: EvaluationContext): string;\n\n  /** Evaluates a number flag, returning its value. */\n  getNumber(key: string, defaultValue: number, context?: EvaluationContext): number;\n\n  /** Evaluates a JSON object flag, returning its payload. Object-ness is verified at runtime; the payload's inner shape is the caller's assertion. */\n  getObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;\n\n  /** Evaluates a boolean flag, returning the full outcome. */\n  evaluateBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): FlagEvaluation<boolean>;\n\n  /** Evaluates a string flag, returning the full outcome. */\n  evaluateString(key: string, defaultValue: string, context?: EvaluationContext): FlagEvaluation<string>;\n\n  /** Evaluates a number flag, returning the full outcome. */\n  evaluateNumber(key: string, defaultValue: number, context?: EvaluationContext): FlagEvaluation<number>;\n\n  /** Evaluates a JSON object flag, returning the full outcome. */\n  evaluateObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue>;\n\n  /** Evaluates any flag, picking the typed path from the runtime type of `defaultValue` — what `useFlag` is built on. */\n  getValue<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;\n\n  /** Evaluates any flag, picking the typed path from the runtime type of `defaultValue`, returning the full outcome. */\n  evaluate<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue>;\n\n  /** Reads the current client-wide evaluation context. */\n  getContext(): EvaluationContext;\n\n  /**\n   * Merges attributes into the client-wide evaluation context — an attribute set to `undefined` is\n   * removed. A merge that changes nothing is a no-op: no listener runs and the provider is not\n   * re-notified, so a context literal rebuilt on every parent render costs nothing (a remote adapter\n   * would otherwise refetch, and every flag consumer re-evaluate, once per parent render).\n   */\n  setContext(context: EvaluationContext): void;\n\n  /** Subscribes to context changes; returns an unsubscribe. */\n  subscribe(listener: FlagContextListener): () => void;\n}\n\n/** Reports whether two attribute values are equal — element-wise for lists, so a re-created array is not a change. */\nfunction attributesEqual(left: ContextAttribute | undefined, right: ContextAttribute | undefined): boolean {\n  if (Array.isArray(left) && Array.isArray(right)) {\n    const rightEntries = right as readonly unknown[];\n    const leftEntries = left as readonly unknown[];\n    return leftEntries.length === rightEntries.length && leftEntries.every((entry, index) => entry === rightEntries[index]);\n  }\n  return left === right;\n}\n\n/** Reports whether two evaluation contexts hold the same attributes. */\nfunction contextsEqual(left: EvaluationContext, right: EvaluationContext): boolean {\n  const leftKeys = Object.keys(left);\n  const rightKeys = Object.keys(right);\n  return leftKeys.length === rightKeys.length && leftKeys.every((key) => attributesEqual(left[key], right[key]));\n}\n\n/** Merges a patch over a context, dropping every attribute explicitly set to `undefined`. */\nfunction mergeContext(base: EvaluationContext, patch: EvaluationContext): EvaluationContext {\n  const merged: Record<string, ContextAttribute | undefined> = { ...base, ...patch };\n  for (const key of Object.keys(merged)) {\n    if (merged[key] === undefined) delete merged[key];\n  }\n  return merged;\n}\n\n/**\n * Creates a flag client over a {@link FlagProvider} — one per app, module scope, shared by the Vue\n * seam ({@link FlagsProvider}) and any non-Vue caller (route guards, api-client wiring, sagas).\n *\n * ```ts\n * export const flags = createFlagClient({\n *   provider: staticFlagProvider({ newNav: { value: false, rules: [{ when: { plan: 'pro' }, value: true }] } }),\n *   onError: (error) => notify({ tone: NoticeTone.Warning, title: `flag ${error.key}: ${error.message}` }),\n * });\n *\n * flags.setContext({ targetingKey: user.id, plan: user.plan });\n * flags.getBoolean('newNav', false);\n * ```\n */\nexport function createFlagClient(options: CreateFlagClientOptions = {}): FlagClient {\n  const provider = options.provider ?? staticFlagProvider();\n  const onError = options.onError;\n  const listeners = new Set<FlagContextListener>();\n  let currentContext: EvaluationContext = options.context ? mergeContext({}, options.context) : {};\n\n  const report = (key: string, errorCode: FlagErrorCode, message: string, cause?: unknown): void => {\n    onError?.({ key, errorCode, message, cause });\n  };\n\n  /** Runs one typed evaluation end to end — the single place every failure mode is turned into a value. */\n  const core = <TValue extends FlagValue>(\n    key: string,\n    defaultValue: TValue,\n    callerContext: EvaluationContext | undefined,\n    resolve: (key: string, context: EvaluationContext) => FlagResolution<FlagValue> | undefined,\n    isValid: (value: FlagValue) => boolean,\n    typeName: string,\n  ): FlagEvaluation<TValue> => {\n    const context = callerContext ? mergeContext(currentContext, callerContext) : currentContext;\n\n    let resolution: FlagResolution<FlagValue> | undefined;\n    try {\n      resolution = resolve(key, context);\n    } catch (cause) {\n      const message = `provider \"${provider.name ?? 'unnamed'}\" threw while resolving \"${key}\"`;\n      report(key, FlagErrorCode.ProviderError, message, cause);\n      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.ProviderError, errorMessage: message };\n    }\n\n    if (resolution === undefined) return { key, value: defaultValue, reason: FlagReason.Default };\n\n    if (resolution.errorCode !== undefined) {\n      const message = resolution.errorMessage ?? `provider reported \"${resolution.errorCode}\" for \"${key}\"`;\n      report(key, resolution.errorCode, message);\n      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: resolution.errorCode, errorMessage: message, variant: resolution.variant };\n    }\n\n    // Gated off: the flag exists but must not apply — the caller's default stands, not the stored value.\n    if (resolution.reason === FlagReason.Disabled) {\n      return { key, value: defaultValue, reason: FlagReason.Disabled, variant: resolution.variant };\n    }\n\n    if (!isValid(resolution.value)) {\n      const message = `flag \"${key}\" resolved to ${typeof resolution.value}, expected ${typeName}`;\n      report(key, FlagErrorCode.TypeMismatch, message);\n      return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.TypeMismatch, errorMessage: message, variant: resolution.variant };\n    }\n\n    // The only cast in the evaluation path, and `isValid` is what earns it: the runtime type of the\n    // resolved value has just been checked against the type `TValue` was inferred from.\n    return { key, value: resolution.value as TValue, reason: resolution.reason ?? FlagReason.Static, variant: resolution.variant };\n  };\n\n  const isBoolean = (value: FlagValue): boolean => typeof value === 'boolean';\n  const isString = (value: FlagValue): boolean => typeof value === 'string';\n  const isNumber = (value: FlagValue): boolean => typeof value === 'number' && Number.isFinite(value);\n  const isJsonObject = (value: FlagValue): boolean => typeof value === 'object' && value !== null && !Array.isArray(value);\n\n  const evaluateBoolean = (key: string, defaultValue: boolean, context?: EvaluationContext): FlagEvaluation<boolean> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, 'boolean');\n\n  const evaluateString = (key: string, defaultValue: string, context?: EvaluationContext): FlagEvaluation<string> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, 'string');\n\n  const evaluateNumber = (key: string, defaultValue: number, context?: EvaluationContext): FlagEvaluation<number> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, 'number');\n\n  const evaluateObject = <TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue> =>\n    core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, 'object');\n\n  const evaluate = <TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue> => {\n    if (typeof defaultValue === 'boolean') return core(key, defaultValue, context, (k, c) => provider.resolveBoolean(k, c), isBoolean, 'boolean');\n    if (typeof defaultValue === 'string') return core(key, defaultValue, context, (k, c) => provider.resolveString(k, c), isString, 'string');\n    if (typeof defaultValue === 'number') return core(key, defaultValue, context, (k, c) => provider.resolveNumber(k, c), isNumber, 'number');\n    if (isJsonObject(defaultValue)) return core(key, defaultValue, context, (k, c) => provider.resolveObject(k, c), isJsonObject, 'object');\n\n    // Unreachable from TypeScript (`FlagValue` covers the four cases above) — reachable from untyped\n    // JS passing `null` / an array / a function as the default. Still total: hand it straight back.\n    const message = `flag \"${key}\" was given a ${typeof defaultValue} default, expected boolean, string, number, or object`;\n    report(key, FlagErrorCode.InvalidDefault, message);\n    return { key, value: defaultValue, reason: FlagReason.Error, errorCode: FlagErrorCode.InvalidDefault, errorMessage: message };\n  };\n\n  const notifyProvider = (context: EvaluationContext): void => {\n    const hook = provider.onContextChange;\n    if (hook === undefined) return;\n    const fail = (cause: unknown): void =>\n      report('', FlagErrorCode.ProviderError, `provider \"${provider.name ?? 'unnamed'}\" failed handling the context change`, cause);\n    try {\n      const pending = hook.call(provider, context);\n      if (pending instanceof Promise) void pending.catch(fail); // a rejected refetch must not become an unhandled rejection\n    } catch (cause) {\n      fail(cause);\n    }\n  };\n\n  return {\n    provider,\n\n    getBoolean: (key, defaultValue, context) => evaluateBoolean(key, defaultValue, context).value,\n    getString: (key, defaultValue, context) => evaluateString(key, defaultValue, context).value,\n    getNumber: (key, defaultValue, context) => evaluateNumber(key, defaultValue, context).value,\n\n    // Generic method shorthand, not an arrow: a non-generic arrow contextually typed by a generic\n    // signature widens `TValue` to its constraint and the return no longer narrows back.\n    getObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue {\n      return evaluateObject(key, defaultValue, context).value;\n    },\n\n    evaluateBoolean,\n    evaluateString,\n    evaluateNumber,\n    evaluateObject,\n\n    getValue<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue {\n      return evaluate(key, defaultValue, context).value;\n    },\n    evaluate,\n\n    getContext: () => currentContext,\n\n    setContext(context: EvaluationContext): void {\n      const next = mergeContext(currentContext, context);\n      if (contextsEqual(currentContext, next)) return; // no-op merge — a per-render context literal costs nothing\n      currentContext = next;\n      notifyProvider(next);\n      for (const listener of [...listeners]) listener(next);\n    },\n\n    subscribe(listener: FlagContextListener): () => void {\n      listeners.add(listener);\n      return () => listeners.delete(listener);\n    },\n  };\n}\n","import {\n  computed,\n  inject,\n  provide,\n  ref,\n  toValue,\n  watch,\n  type ComputedRef,\n  type InjectionKey,\n  type MaybeRefOrGetter,\n  type Ref,\n} from 'vue';\n\nimport { createFlagClient, type FlagClient } from './FlagClient';\nimport type { FlagValue } from './FlagTypes';\n\n/*\n * The Vue seam over `FlagClient` — the provide/inject + composable pattern used by\n * `foundation/primitives`' `DirectionProvider`, including its standalone fallback: `useFlag` works\n * with no provider mounted (every flag returns the caller's default), so an SDK component may read\n * a flag without forcing every consuming app to wire one.\n *\n * NOTE ON NAMING: `FlagsProvider` (plural) is the Vue component in `FlagsProvider.vue`;\n * `FlagProvider` (singular, `FlagProvider.ts`) is the backend adapter it evaluates against. Same\n * split as OpenFeature.\n *\n * RE-EVALUATION ON CONTEXT CHANGE. The client is created once and never re-created — swapping it\n * mid-life would drop its subscribers — so a context change cannot propagate by client identity.\n * Instead the provider subscribes to the client and bumps a `revision` ref; every `useFlag` computed\n * reads that ref, so a context change invalidates all of them at once. Evaluation is a synchronous\n * map lookup, so the computed re-evaluates on read with no extra bookkeeping, and never goes stale.\n *\n * WHERE THIS BEATS THE REACT ORIGINAL. React re-rendered every consumer of the context on every\n * revision bump, because the context VALUE carried the revision. Here the revision is a ref read\n * inside each `useFlag` computed, so only the flags actually read are re-evaluated, and only the\n * components that depend on a CHANGED flag re-render — Vue's dependency graph does the narrowing\n * that React's context could not.\n */\n\n/** The active client plus the counter that re-evaluates consumers when the evaluation context moves. */\ninterface FlagsContextValue {\n  /** The client in force. A computed, so a swapped `client` prop still reaches every consumer. */\n  readonly client: ComputedRef<FlagClient>;\n\n  /** Bumped on every context change — what invalidates each `useFlag` computed. */\n  readonly revision: Ref<number>;\n}\n\n/**\n * React's `createContext<FlagsContextValue | undefined>(undefined)` becomes an `InjectionKey` plus\n * the standalone fallback resolved at the injection site. Deliberately NOT re-exported from\n * `index.ts`: the React original kept its context module-private, and the barrel shape is preserved.\n */\nconst FlagsKey: InjectionKey<FlagsContextValue> = Symbol('wow-two.flags');\n\n/**\n * Backs the composables when no `FlagsProvider` is mounted — an empty static provider, so every flag\n * returns the caller's default. Built lazily and memoised rather than at module scope, so merely\n * importing this module allocates nothing; `revision` never bumps, because nothing can move it.\n */\nlet standalone: FlagsContextValue | undefined;\n\nfunction standaloneContext(): FlagsContextValue {\n  if (!standalone) {\n    const client = createFlagClient();\n    standalone = { client: computed(() => client), revision: ref(0) };\n  }\n  return standalone;\n}\n\n/**\n * The provider half — used by `FlagsProvider`, and by any component that owns a flag client.\n * Subscribes to the client and re-subscribes if the active client is swapped, disposing the previous\n * subscription through the watcher's `onCleanup`.\n *\n * Pass `client` as a getter (`() => props.client ?? ownClient`) so the active client stays tracked.\n */\nexport function provideFlags(client: MaybeRefOrGetter<FlagClient>): void {\n  const active = computed(() => toValue(client));\n  const revision = ref(0);\n\n  // React bumped a `revision` into component state from an effect; the Vue equivalent is a watcher\n  // that owns the subscription. `immediate` is safe under SSR — `subscribe` only adds to a Set and\n  // touches no browser global.\n  watch(\n    active,\n    (current, _previous, onCleanup) => {\n      onCleanup(current.subscribe(() => (revision.value += 1)));\n    },\n    { immediate: true },\n  );\n\n  provide(FlagsKey, { client: active, revision });\n}\n\n/** Resolves the surrounding flags context, or the standalone fallback when no provider is mounted. */\nfunction resolveFlags(): FlagsContextValue {\n  return inject(FlagsKey, standaloneContext, true);\n}\n\n/**\n * Reads the flag client. Works without a {@link FlagsProvider} — falls back to an empty one, where\n * every flag returns the caller's default.\n *\n * Returns the plain `FlagClient` rather than a ref, matching the React original: the client is\n * created once and never re-created, so there is nothing to track. Use it for imperative reads and\n * for `setContext`; for a value that must re-evaluate when the evaluation context moves, use\n * {@link useFlag}, whose computed is the reactive path.\n */\nexport function useFlags(): FlagClient {\n  return resolveFlags().client.value;\n}\n\n/**\n * Reads one flag's value, re-evaluating whenever the evaluation context changes. The typed path is\n * picked from `defaultValue`, which also types the result — `useFlag('newNav', false)` is\n * `ComputedRef<boolean>`, `useFlag('limits', { max: 10 })` is a computed of that object type.\n *\n * Diverges from the React original, which returned a bare `TValue` re-read on every render: this\n * returns a `ComputedRef<TValue>`, because a bare value could never re-evaluate. `key` and\n * `defaultValue` may each be a ref or getter — changing either re-evaluates the flag, which the\n * React signature could not express at all.\n */\nexport function useFlag<TValue extends FlagValue>(\n  key: MaybeRefOrGetter<string>,\n  defaultValue: MaybeRefOrGetter<TValue>,\n): ComputedRef<TValue> {\n  const { client, revision } = resolveFlags();\n  return computed<TValue>(() => {\n    // `revision` is the dependency that re-evaluates this flag when the evaluation context moves.\n    // Read through `void` rather than discarded into a binding — the read IS the subscription.\n    void revision.value;\n    return client.value.getValue(toValue(key), toValue(defaultValue));\n  });\n}\n","<script lang=\"ts\">\nimport type { FlagClient, FlagErrorListener } from './FlagClient';\nimport type { FlagProvider } from './FlagProvider';\nimport type { EvaluationContext } from './FlagTypes';\n\n/** Defines the props for {@link FlagsProvider}. */\nexport interface FlagsProviderProps {\n  /** An existing client to serve — the app-wide instance shared with non-Vue callers. Takes precedence over `provider` / `onError`. */\n  client?: FlagClient;\n\n  /** The flag source to build a client around, when no `client` is passed. Read once, at setup. */\n  provider?: FlagProvider;\n\n  /** The evaluation context. Kept in sync on every change — a fresh object literal per render is safe. */\n  context?: EvaluationContext;\n\n  /** Receives evaluation faults, when no `client` is passed. Read once, at setup. */\n  onError?: FlagErrorListener;\n}\n</script>\n\n<script setup lang=\"ts\">\nimport { watch } from 'vue';\n\nimport { createFlagClient } from './FlagClient';\nimport { provideFlags } from './FlagsContext';\n\n/**\n * Provides flag evaluation to every descendant and re-evaluates them whenever the evaluation context\n * changes — including changes made imperatively through `client.setContext(…)` outside Vue.\n *\n * ```vue\n * <FlagsProvider :client=\"flags\" :context=\"{ targetingKey: user.id, plan: user.plan }\">\n *   <App />\n * </FlagsProvider>\n * ```\n *\n * Renders no element of its own — the slot passes straight through, matching `DirectionProvider`.\n */\ndefineOptions({ name: 'FlagsProvider' });\n\nconst props = defineProps<FlagsProviderProps>();\n\n// `setup` runs exactly once per instance, which is precisely what React's lazy `useState`\n// initializer was working around — the client must be created once for the component's life, and a\n// `computed` would be allowed to drop and re-run it.\nconst ownClient = props.client ?? createFlagClient({ provider: props.provider, context: props.context, onError: props.onError });\n\n// A getter, not a snapshot: a swapped `client` prop re-subscribes and reaches every consumer.\nprovideFlags(() => props.client ?? ownClient);\n\n// The `context` prop syncs in through a watcher rather than at construction, so a fresh object\n// literal per render is safe: `setContext` no-ops when the merge changes nothing, so a parent that\n// rebuilds its context literal every render neither refetches nor re-evaluates flag consumers.\n//\n// `immediate` lands the context during setup, BEFORE descendants first evaluate — where React's\n// effect ran after mount, so a passed-in `client` briefly evaluated against a stale targeting\n// context and every gated element could flash. SSR-safe: `setContext` touches no browser global.\nwatch(\n  [() => props.client ?? ownClient, () => props.context],\n  ([client, context]) => {\n    if (context !== undefined) client.setContext(context);\n  },\n  { immediate: true },\n);\n</script>\n\n<template>\n  <slot />\n</template>\n"],"names":["_renderSlot"],"mappings":"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"}