@schematichq/schematic-vue 1.2.16 → 1.4.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Schematic
+Copyright (c) 2023-2026 Schematic, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -19,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

package/README.md

@@ -137,6 +137,104 @@ const {
 
 _Note: `useSchematicIsPending` is checking if entitlement data has been loaded, typically via `identify`. It should, therefore, be used to wrap flag and entitlement checks, but never the initial call to `identify`._
 
+### Company plan information
+
+To access the current company's plan and trial status, you can use the `useSchematicPlan` composable:
+
+```vue
+<script setup lang="ts">
+import { useSchematicPlan } from "@schematichq/schematic-vue";
+
+const plan = useSchematicPlan();
+</script>
+
+<template>
+  <div v-if="!plan">No plan assigned</div>
+  <div v-else>
+    <p>Current plan: {{ plan.name }}</p>
+
+    <p v-if="plan.trialStatus === 'active'">
+      Trial ends: {{ plan.trialEndDate?.toLocaleDateString() }}
+    </p>
+
+    <p v-if="plan.trialStatus === 'expired'">
+      Your trial has ended. <a href="/upgrade">Upgrade now</a>
+    </p>
+  </div>
+</template>
+```
+
+The composable returns an object with the following properties:
+
+| Property | Type | Description |
+| --- | --- | --- |
+| `id` | `string` | The plan ID |
+| `name` | `string` | The plan name |
+| `trialEndDate` | `Date \| undefined` | The trial end date, if the company has or had a trial |
+| `trialStatus` | `"active" \| "expired" \| "converted" \| undefined` | The company's trial status: `active` if the trial is ongoing, `expired` if the trial ended without conversion, `converted` if the company converted to a paid plan, or `undefined` if the company has never trialed |
+
+## Fallback Behavior
+
+The SDK includes built-in fallback behavior you can use to ensure your application continues to function even when unable to reach Schematic (e.g., during service disruptions or network issues).
+
+### Flag Check Fallbacks
+
+When flag checks cannot reach Schematic, they use fallback values in the following priority order:
+
+1. Callsite fallback - fallback values can be provided directly in the composable options
+2. Initialization defaults - fallback values configured via `flagCheckDefaults` or `flagValueDefaults` options when initializing the plugin
+3. Default value - Returns `false` if no fallback is configured
+
+```vue
+<script setup lang="ts">
+// Provide a fallback value at the callsite
+import { useSchematicFlag } from "@schematichq/schematic-vue";
+
+const isFeatureEnabled = useSchematicFlag("feature-flag", {
+    fallback: true,  // Used if API request fails
+});
+</script>
+
+<template>
+    <Feature v-if="isFeatureEnabled" />
+    <Fallback v-else />
+</template>
+```
+
+```typescript
+// Or configure defaults at initialization
+import { createApp } from "vue";
+import { SchematicPlugin } from "@schematichq/schematic-vue";
+
+const app = createApp(App);
+app.use(SchematicPlugin, {
+    publishableKey: "your-publishable-key",
+    flagValueDefaults: {
+        "feature-flag": true,  // Used if API request fails and no callsite fallback
+    },
+    flagCheckDefaults: {
+        "another-flag": {
+            flag: "another-flag",
+            value: true,
+            reason: "Default value",
+        },
+    },
+});
+```
+
+### Event Queueing and Retry
+
+When events (track, identify) cannot be sent due to network issues, they are automatically queued and retried:
+
+- Events are queued in memory (up to 100 events by default, configurable via `maxEventQueueSize`)
+- Failed events are retried with exponential backoff (up to 5 attempts by default, configurable via `maxEventRetries`)
+- Events are automatically flushed when the network connection is restored
+- Events queued when the page is hidden are sent when the page becomes visible
+
+### WebSocket Fallback
+
+In WebSocket mode, if the WebSocket connection fails, the SDK will provide the last known value or the configured fallback values as [outlined above](/#flag-check-fallbacks). The WebSocket will also automatically attempt to re-establish it's connection with Schematic using an exponential backoff. 
+
 ## Options API Support
 
 While the primary API uses the Composition API, you can still use these composables in the Options API:

package/dist/schematic-vue.cjs.js

@@ -30,7 +30,8 @@ __export(index_exports, {
   useSchematicEntitlement: () => useSchematicEntitlement,
   useSchematicEvents: () => useSchematicEvents,
   useSchematicFlag: () => useSchematicFlag,
-  useSchematicIsPending: () => useSchematicIsPending
+  useSchematicIsPending: () => useSchematicIsPending,
+  useSchematicPlan: () => useSchematicPlan
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -642,6 +643,36 @@ function v4(options, buf, offset) {
 }
 var v4_default = v4;
 var import_polyfill = __toESM(require_browser_polyfill());
+function EntitlementValueTypeFromJSON(json) {
+  return EntitlementValueTypeFromJSONTyped(json, false);
+}
+function EntitlementValueTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function FeatureEntitlementFromJSON(json) {
+  return FeatureEntitlementFromJSONTyped(json, false);
+}
+function FeatureEntitlementFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    allocation: json["allocation"] == null ? void 0 : json["allocation"],
+    creditId: json["credit_id"] == null ? void 0 : json["credit_id"],
+    creditRemaining: json["credit_remaining"] == null ? void 0 : json["credit_remaining"],
+    creditTotal: json["credit_total"] == null ? void 0 : json["credit_total"],
+    creditUsed: json["credit_used"] == null ? void 0 : json["credit_used"],
+    eventName: json["event_name"] == null ? void 0 : json["event_name"],
+    featureId: json["feature_id"],
+    featureKey: json["feature_key"],
+    metricPeriod: json["metric_period"] == null ? void 0 : json["metric_period"],
+    metricResetAt: json["metric_reset_at"] == null ? void 0 : new Date(json["metric_reset_at"]),
+    monthReset: json["month_reset"] == null ? void 0 : json["month_reset"],
+    softLimit: json["soft_limit"] == null ? void 0 : json["soft_limit"],
+    usage: json["usage"] == null ? void 0 : json["usage"],
+    valueType: EntitlementValueTypeFromJSON(json["value_type"])
+  };
+}
 function CheckFlagResponseDataFromJSON(json) {
   return CheckFlagResponseDataFromJSONTyped(json, false);
 }
@@ -651,6 +682,7 @@ function CheckFlagResponseDataFromJSONTyped(json, ignoreDiscriminator) {
   }
   return {
     companyId: json["company_id"] == null ? void 0 : json["company_id"],
+    entitlement: json["entitlement"] == null ? void 0 : FeatureEntitlementFromJSON(json["entitlement"]),
     error: json["error"] == null ? void 0 : json["error"],
     featureAllocation: json["feature_allocation"] == null ? void 0 : json["feature_allocation"],
     featureUsage: json["feature_usage"] == null ? void 0 : json["feature_usage"],
@@ -666,26 +698,6 @@ function CheckFlagResponseDataFromJSONTyped(json, ignoreDiscriminator) {
     value: json["value"]
   };
 }
-function EventBodyFlagCheckToJSON(json) {
-  return EventBodyFlagCheckToJSONTyped(json, false);
-}
-function EventBodyFlagCheckToJSONTyped(value, ignoreDiscriminator = false) {
-  if (value == null) {
-    return value;
-  }
-  return {
-    company_id: value["companyId"],
-    error: value["error"],
-    flag_id: value["flagId"],
-    flag_key: value["flagKey"],
-    reason: value["reason"],
-    req_company: value["reqCompany"],
-    req_user: value["reqUser"],
-    rule_id: value["ruleId"],
-    user_id: value["userId"],
-    value: value["value"]
-  };
-}
 function CheckFlagResponseFromJSON(json) {
   return CheckFlagResponseFromJSONTyped(json, false);
 }
@@ -698,6 +710,26 @@ function CheckFlagResponseFromJSONTyped(json, ignoreDiscriminator) {
     params: json["params"]
   };
 }
+function TrialStatusFromJSON(json) {
+  return TrialStatusFromJSONTyped(json, false);
+}
+function TrialStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function DatastreamCompanyPlanFromJSON(json) {
+  return DatastreamCompanyPlanFromJSONTyped(json, false);
+}
+function DatastreamCompanyPlanFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    id: json["id"],
+    name: json["name"],
+    trialEndDate: json["trial_end_date"] == null ? void 0 : new Date(json["trial_end_date"]),
+    trialStatus: json["trial_status"] == null ? void 0 : TrialStatusFromJSON(json["trial_status"])
+  };
+}
 function CheckFlagsResponseDataFromJSON(json) {
   return CheckFlagsResponseDataFromJSONTyped(json, false);
 }
@@ -706,7 +738,8 @@ function CheckFlagsResponseDataFromJSONTyped(json, ignoreDiscriminator) {
     return json;
   }
   return {
-    flags: json["flags"].map(CheckFlagResponseDataFromJSON)
+    flags: json["flags"].map(CheckFlagResponseDataFromJSON),
+    plan: json["plan"] == null ? void 0 : DatastreamCompanyPlanFromJSON(json["plan"])
   };
 }
 function CheckFlagsResponseFromJSON(json) {
@@ -721,6 +754,26 @@ function CheckFlagsResponseFromJSONTyped(json, ignoreDiscriminator) {
     params: json["params"]
   };
 }
+function EventBodyFlagCheckToJSON(json) {
+  return EventBodyFlagCheckToJSONTyped(json, false);
+}
+function EventBodyFlagCheckToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    company_id: value["companyId"],
+    error: value["error"],
+    flag_id: value["flagId"],
+    flag_key: value["flagKey"],
+    reason: value["reason"],
+    req_company: value["reqCompany"],
+    req_user: value["reqUser"],
+    rule_id: value["ruleId"],
+    user_id: value["userId"],
+    value: value["value"]
+  };
+}
 var RuleType = /* @__PURE__ */ ((RuleType2) => {
   RuleType2["GLOBAL_OVERRIDE"] = "global_override";
   RuleType2["COMPANY_OVERRIDE"] = "company_override";
@@ -741,6 +794,7 @@ var UsagePeriod = /* @__PURE__ */ ((UsagePeriod2) => {
 var CheckFlagReturnFromJSON = (json) => {
   const {
     companyId,
+    entitlement,
     error,
     featureAllocation,
     featureUsage,
@@ -758,24 +812,40 @@ var CheckFlagReturnFromJSON = (json) => {
   const featureUsageExceeded = !value && // if flag is not false, then we haven't exceeded usage
   (ruleType == "company_override_usage_exceeded" || // if the rule type is one of these, then we have exceeded usage
   ruleType == "plan_entitlement_usage_exceeded");
+  const resolvedAllocation = entitlement?.allocation ?? featureAllocation;
+  const resolvedUsage = entitlement?.usage ?? featureUsage;
+  const resolvedEvent = entitlement?.eventName ?? featureUsageEvent;
+  const resolvedPeriod = entitlement?.metricPeriod ?? featureUsagePeriod;
+  const resolvedResetAt = entitlement?.metricResetAt ?? featureUsageResetAt;
   return {
     featureUsageExceeded,
     companyId: companyId == null ? void 0 : companyId,
+    creditRemaining: entitlement?.creditRemaining == null ? void 0 : entitlement.creditRemaining,
     error: error == null ? void 0 : error,
-    featureAllocation: featureAllocation == null ? void 0 : featureAllocation,
-    featureUsage: featureUsage == null ? void 0 : featureUsage,
-    featureUsageEvent: featureUsageEvent === null ? void 0 : featureUsageEvent,
-    featureUsagePeriod: featureUsagePeriod == null ? void 0 : featureUsagePeriod,
-    featureUsageResetAt: featureUsageResetAt == null ? void 0 : featureUsageResetAt,
+    featureAllocation: resolvedAllocation == null ? void 0 : resolvedAllocation,
+    featureUsage: resolvedUsage == null ? void 0 : resolvedUsage,
+    featureUsageEvent: resolvedEvent == null ? void 0 : resolvedEvent,
+    featureUsagePeriod: resolvedPeriod == null ? void 0 : resolvedPeriod,
+    featureUsageResetAt: resolvedResetAt == null ? void 0 : resolvedResetAt,
     flag,
     flagId: flagId == null ? void 0 : flagId,
     reason,
     ruleId: ruleId == null ? void 0 : ruleId,
     ruleType: ruleType == null ? void 0 : ruleType,
+    softLimit: entitlement?.softLimit == null ? void 0 : entitlement.softLimit,
     userId: userId == null ? void 0 : userId,
     value
   };
 };
+var CheckPlanReturnFromJSON = (json) => {
+  const { id, name, trialEndDate, trialStatus } = DatastreamCompanyPlanFromJSON(json);
+  return {
+    id,
+    name,
+    trialEndDate: trialEndDate == null ? void 0 : trialEndDate,
+    trialStatus: trialStatus == null ? void 0 : trialStatus
+  };
+};
 function contextString(context) {
   const sortedContext = Object.keys(context).reduce((acc, key) => {
     const sortedKeys = Object.keys(
@@ -790,7 +860,7 @@ function contextString(context) {
   }, {});
   return JSON.stringify(sortedContext);
 }
-var version = "1.2.16";
+var version = "1.4.0";
 var anonymousIdKey = "schematicId";
 var Schematic = class {
   additionalHeaders = {};
@@ -807,10 +877,12 @@ var Schematic = class {
   flagValueListeners = {};
   isPending = true;
   isPendingListeners = /* @__PURE__ */ new Set();
+  planListeners = /* @__PURE__ */ new Set();
   storage;
   useWebSocket = false;
   checks = {};
   featureUsageEventMap = {};
+  planChecks = {};
   webSocketUrl = "wss://api.schematichq.com";
   webSocketConnectionTimeout = 1e4;
   webSocketReconnect = true;
@@ -836,6 +908,7 @@ var Schematic = class {
   retryTimer = null;
   flagValueDefaults = {};
   flagCheckDefaults = {};
+  fallbackCheckCache = {};
   constructor(apiKey, options) {
     this.apiKey = apiKey;
     this.eventQueue = [];
@@ -1004,8 +1077,8 @@ var Schematic = class {
   /**
    * Get value for a single flag.
    * In WebSocket mode, returns cached values if connection is active, otherwise establishes
-   * new connection and then returns the requestedvalue. Falls back to REST API if WebSocket
-   * connection fails.
+   * new connection and then returns the requested value. Falls back to preconfigured fallback
+   * values if WebSocket connection fails.
    * In REST mode, makes an API call for each check.
    */
   async checkFlag(options) {
@@ -1074,10 +1147,17 @@ var Schematic = class {
         await this.setContext(context);
       } catch (error) {
         console.warn(
-          "WebSocket connection failed, falling back to REST:",
+          "WebSocket connection failed, using fallback value:",
           error
         );
-        return this.fallbackToRest(key, context, fallback);
+        const errorResult = this.resolveFallbackCheckFlagReturn(
+          key,
+          fallback,
+          "WebSocket connection failed",
+          error instanceof Error ? error.message : String(error)
+        );
+        this.submitFlagCheckEvent(key, errorResult, context);
+        return errorResult.value;
       }
       const contextVals = this.checks[contextStr] ?? {};
       const flagCheck = contextVals[key];
@@ -1088,6 +1168,13 @@ var Schematic = class {
       );
       if (typeof flagCheck !== "undefined") {
         this.submitFlagCheckEvent(key, flagCheck, context);
+      } else {
+        const fallbackResult = this.resolveFallbackCheckFlagReturn(
+          key,
+          fallback,
+          "No flag values available"
+        );
+        this.submitFlagCheckEvent(key, fallbackResult, context);
       }
       return result;
     } catch (error) {
@@ -1128,28 +1215,32 @@ var Schematic = class {
           this.checks[contextStr] = {};
         }
         this.checks[contextStr][flagCheck.flag] = flagCheck;
-        this.debug(`WebSocket flag update:`, {
-          flag: flagCheck.flag,
-          value: flagCheck.value,
-          flagCheck
-        });
         if (typeof flagCheck.featureUsageEvent === "string") {
           this.updateFeatureUsageEventMap(flagCheck);
         }
         if ((this.flagCheckListeners[flag.flag]?.size ?? 0) > 0 || (this.flagValueListeners[flag.flag]?.size ?? 0) > 0) {
           this.submitFlagCheckEvent(flagCheck.flag, flagCheck, context);
         }
-        this.debug(`About to notify listeners for flag ${flag.flag}`, {
-          flag: flag.flag,
-          value: flagCheck.value
-        });
+        this.debug(
+          `WebSocket flag update received. Notifying listeners for ${flag.flag}`,
+          {
+            flag: flag.flag,
+            value: flagCheck.value,
+            flagCheck
+          }
+        );
         this.notifyFlagCheckListeners(flag.flag, flagCheck);
         this.notifyFlagValueListeners(flag.flag, flagCheck.value);
-        this.debug(`Finished notifying listeners for flag ${flag.flag}`, {
-          flag: flag.flag,
-          value: flagCheck.value
-        });
       });
+      if (message.plan !== void 0 && message.plan !== null) {
+        const plan = CheckPlanReturnFromJSON(message.plan);
+        const contextStr = contextString(context);
+        this.planChecks[contextStr] = plan;
+        this.debug(`WebSocket plan update received. Notifying listeners`, {
+          plan
+        });
+        this.notifyPlanListeners(plan);
+      }
       this.flushContextDependentEventQueue();
       this.setIsPending(false);
     };
@@ -1180,53 +1271,6 @@ var Schematic = class {
     this.debug(`submitting flag check event:`, eventBody);
     return this.handleEvent("flag_check", EventBodyFlagCheckToJSON(eventBody));
   }
-  /**
-   * Helper method for falling back to REST API when WebSocket connection fails
-   */
-  async fallbackToRest(key, context, fallback) {
-    if (this.isOffline()) {
-      const resolvedFallback = this.resolveFallbackValue(key, fallback);
-      this.debug(`fallbackToRest offline result: ${key}`, {
-        value: resolvedFallback,
-        offlineMode: true
-      });
-      return resolvedFallback;
-    }
-    try {
-      const requestUrl = `${this.apiUrl}/flags/${key}/check`;
-      const response = await fetch(requestUrl, {
-        method: "POST",
-        headers: {
-          ...this.additionalHeaders ?? {},
-          "Content-Type": "application/json;charset=UTF-8",
-          "X-Schematic-Api-Key": this.apiKey
-        },
-        body: JSON.stringify(context)
-      });
-      if (!response.ok) {
-        throw new Error("Network response was not ok");
-      }
-      const responseJson = await response.json();
-      const data = CheckFlagResponseFromJSON(responseJson);
-      this.debug(`fallbackToRest result: ${key}`, data);
-      const result = CheckFlagReturnFromJSON(data.data);
-      if (typeof result.featureUsageEvent === "string") {
-        this.updateFeatureUsageEventMap(result);
-      }
-      this.submitFlagCheckEvent(key, result, context);
-      return result.value;
-    } catch (error) {
-      console.warn("REST API call failed, using fallback value:", error);
-      const errorResult = this.resolveFallbackCheckFlagReturn(
-        key,
-        fallback,
-        "API request failed (fallback)",
-        error instanceof Error ? error.message : String(error)
-      );
-      this.submitFlagCheckEvent(key, errorResult, context);
-      return errorResult.value;
-    }
-  }
   /**
    * Make an API call to fetch all flag values for a given context.
    * Recommended for use in REST mode only.
@@ -1300,6 +1344,9 @@ var Schematic = class {
       this.setIsPending(false);
       return Promise.resolve();
     }
+    if (contextString(context) === contextString(this.context) && this.conn !== null && !this.isPending) {
+      return;
+    }
     try {
       this.setIsPending(true);
       if (!this.conn) {
@@ -1339,7 +1386,10 @@ var Schematic = class {
       await this.wsSendMessage(socket, context);
     } catch (error) {
       console.warn("Failed to establish WebSocket connection:", error);
-      throw error;
+      this.context = context;
+      this.flushContextDependentEventQueue();
+      this.setIsPending(false);
+      this.attemptReconnect();
     }
   };
   /**
@@ -1980,7 +2030,10 @@ var Schematic = class {
           clearTimeout(timeoutId);
         }
         this.debug(`WebSocket connection ${connectionId} error:`, error);
-        reject(error);
+        const wrappedError = new Error(
+          "WebSocket connection failed during handshake"
+        );
+        reject(wrappedError);
       };
       webSocket.onclose = () => {
         if (timeoutId !== null) {
@@ -2027,6 +2080,20 @@ var Schematic = class {
           }
         };
         socket.addEventListener("message", messageHandler);
+        socket.addEventListener("close", (event) => {
+          if (!resolved) {
+            resolved = true;
+            if (event.code === 4001) {
+              reject(
+                new Error(
+                  `Authentication failed: ${event.reason !== "" ? event.reason : "Invalid API key"}`
+                )
+              );
+            } else {
+              reject(new Error("WebSocket connection closed unexpectedly"));
+            }
+          }
+        });
         this.currentWebSocket = socket;
         const clientVersion = this.additionalHeaders["X-Schematic-Client-Version"] ?? `schematic-js@${version}`;
         const messagePayload = {
@@ -2063,11 +2130,17 @@ var Schematic = class {
     };
   };
   setIsPending = (isPending) => {
+    if (this.isPending === isPending) return;
     this.isPending = isPending;
     this.isPendingListeners.forEach(
       (listener) => notifyPendingListener(listener, isPending)
     );
   };
+  getPlan = () => {
+    const contextStr = contextString(this.context);
+    const plan = this.planChecks[contextStr];
+    return plan;
+  };
   // flag checks state
   getFlagCheck = (flagKey) => {
     const contextStr = contextString(this.context);
@@ -2077,11 +2150,14 @@ var Schematic = class {
       return check;
     }
     if (flagKey in this.flagCheckDefaults || flagKey in this.flagValueDefaults) {
-      return this.resolveFallbackCheckFlagReturn(
-        flagKey,
-        void 0,
-        "Default value used"
-      );
+      if (!(flagKey in this.fallbackCheckCache)) {
+        this.fallbackCheckCache[flagKey] = this.resolveFallbackCheckFlagReturn(
+          flagKey,
+          void 0,
+          "Default value used"
+        );
+      }
+      return this.fallbackCheckCache[flagKey];
     }
     return void 0;
   };
@@ -2118,6 +2194,12 @@ var Schematic = class {
       this.flagCheckListeners[flagKey].delete(listener);
     };
   };
+  addPlanListener = (listener) => {
+    this.planListeners.add(listener);
+    return () => {
+      this.planListeners.delete(listener);
+    };
+  };
   notifyFlagCheckListeners = (flagKey, check) => {
     const listeners = this.flagCheckListeners?.[flagKey] ?? [];
     if (listeners.size > 0) {
@@ -2166,6 +2248,21 @@ var Schematic = class {
       });
     });
   };
+  notifyPlanListeners = (value) => {
+    const listeners = this.planListeners ?? [];
+    if (listeners.size > 0) {
+      this.debug(`Notifying ${listeners.size} plan listeners`, { value });
+    }
+    listeners.forEach((listener, index) => {
+      this.debug(`Calling listener ${index} for plan`, {
+        value
+      });
+      notifyPlanListener(listener, value);
+      this.debug(`Listener ${index} for plan completed`, {
+        value
+      });
+    });
+  };
 };
 var notifyPendingListener = (listener, value) => {
   if (listener.length > 0) {
@@ -2188,12 +2285,19 @@ var notifyFlagValueListener = (listener, value) => {
     listener();
   }
 };
+var notifyPlanListener = (listener, value) => {
+  if (listener.length > 0) {
+    listener(value);
+  } else {
+    listener();
+  }
+};
 
 // src/context/schematic.ts
 var import_vue = require("vue");
 
 // src/version.ts
-var version2 = "1.2.16";
+var version2 = "1.4.1";
 
 // src/context/schematic.ts
 var SchematicSymbol = Symbol("schematic");
@@ -2309,6 +2413,23 @@ var useSchematicEntitlement = (key, opts) => {
     userId: (0, import_vue2.computed)(() => flagCheck.value.userId)
   };
 };
+var useSchematicPlan = (opts) => {
+  const client = useSchematicClient(opts);
+  const fallback = opts?.fallback;
+  const plan = (0, import_vue2.ref)(
+    client.getPlan() ?? fallback
+  );
+  let unsubscribe = null;
+  (0, import_vue2.onMounted)(() => {
+    unsubscribe = client.addPlanListener((value) => {
+      plan.value = value;
+    });
+  });
+  (0, import_vue2.onScopeDispose)(() => {
+    unsubscribe?.();
+  });
+  return plan;
+};
 var useSchematicIsPending = (opts) => {
   const client = useSchematicClient(opts);
   const isPending = (0, import_vue2.ref)(client.getIsPending());