@vexillo/react-sdk 2.1.0 → 2.2.0

package/dist/index.js

@@ -0,0 +1,146 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  VexilloProvider: () => VexilloProvider,
+  fetchFlags: () => fetchFlags,
+  useFlag: () => useFlag
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/provider.tsx
+var import_react2 = require("react");
+
+// src/fetch-flags.ts
+async function fetchFlags(baseUrl, apiKey) {
+  try {
+    const res = await fetch(`${baseUrl}/api/flags`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!res.ok) {
+      console.warn(
+        `Vexillo: fetchFlags received status ${res.status} ${res.statusText}. Returning empty flags.`
+      );
+      return {};
+    }
+    const data = await res.json();
+    const map = {};
+    for (const f of data.flags) {
+      map[f.key] = f.enabled;
+    }
+    return map;
+  } catch (e) {
+    console.warn("Vexillo: fetchFlags failed. Returning empty flags.");
+    return {};
+  }
+}
+
+// src/use-promise.ts
+var import_react = require("react");
+function usePromise(promise) {
+  const major = parseInt(import_react.version.split(".")[0], 10);
+  if (major >= 19 && typeof import_react.use === "function") {
+    return (0, import_react.use)(promise);
+  }
+  return readPromise(promise);
+}
+function readPromise(promise) {
+  if (promise.status === "fulfilled") {
+    return promise.value;
+  }
+  if (promise.status === "rejected") {
+    throw promise.reason;
+  }
+  if (promise.status === "pending") {
+    throw promise;
+  }
+  promise.status = "pending";
+  promise.then(
+    (value) => {
+      promise.status = "fulfilled";
+      promise.value = value;
+    },
+    (reason) => {
+      promise.status = "rejected";
+      promise.reason = reason;
+    }
+  );
+  throw promise;
+}
+
+// src/provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var VexilloContext = (0, import_react2.createContext)(null);
+var clientCache = /* @__PURE__ */ new Map();
+function getOrCreateFlagPromise(baseUrl, apiKey) {
+  const key = `${baseUrl}__${apiKey}`;
+  if (!clientCache.has(key)) {
+    clientCache.set(key, fetchFlags(baseUrl, apiKey));
+  }
+  return clientCache.get(key);
+}
+function VexilloProvider({
+  baseUrl,
+  apiKey,
+  initialFlags,
+  fallbacks = {},
+  children
+}) {
+  const isServer = typeof window === "undefined";
+  if (initialFlags) {
+    const key = `${baseUrl}__${apiKey}`;
+    if (!isServer && !clientCache.has(key)) {
+      clientCache.set(key, Promise.resolve(initialFlags));
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(VexilloContext.Provider, { value: { flags: initialFlags, fallbacks }, children });
+  }
+  let flagPromise;
+  if (isServer) {
+    flagPromise = fetchFlags(baseUrl, apiKey);
+  } else {
+    flagPromise = getOrCreateFlagPromise(baseUrl, apiKey);
+  }
+  const flags = usePromise(flagPromise);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(VexilloContext.Provider, { value: { flags, fallbacks }, children });
+}
+function useVexilloContext() {
+  const ctx = (0, import_react2.useContext)(VexilloContext);
+  if (ctx === null) {
+    throw new Error("useFlag must be called inside a <VexilloProvider>.");
+  }
+  return ctx;
+}
+
+// src/use-flag.ts
+function useFlag(key) {
+  var _a;
+  const { flags, fallbacks } = useVexilloContext();
+  if (key in flags) {
+    return flags[key];
+  }
+  return (_a = fallbacks[key]) != null ? _a : false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VexilloProvider,
+  fetchFlags,
+  useFlag
+});

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@vexillo/react-sdk",
-  "version": "2.1.0",
-  "type": "module",
+  "version": "2.2.0",
   "license": "MIT",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [