@openfeature/web-sdk 0.0.2-experimental

package/dist/cjs/index.js

@@ -0,0 +1,598 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiEvents: () => ApiEvents,
+  DefaultLogger: () => DefaultLogger,
+  ErrorCode: () => ErrorCode,
+  FlagNotFoundError: () => FlagNotFoundError,
+  GeneralError: () => GeneralError,
+  InvalidContextError: () => InvalidContextError,
+  NOOP_PROVIDER: () => NOOP_PROVIDER,
+  NOOP_TRANSACTION_CONTEXT_PROPAGATOR: () => NOOP_TRANSACTION_CONTEXT_PROPAGATOR,
+  OpenFeature: () => OpenFeature,
+  OpenFeatureAPI: () => OpenFeatureAPI,
+  OpenFeatureClient: () => OpenFeatureClient,
+  OpenFeatureCommonAPI: () => OpenFeatureCommonAPI,
+  OpenFeatureError: () => OpenFeatureError,
+  ParseError: () => ParseError,
+  ProviderEvents: () => ProviderEvents,
+  SafeLogger: () => SafeLogger,
+  StandardResolutionReasons: () => StandardResolutionReasons,
+  TargetingKeyMissingError: () => TargetingKeyMissingError,
+  TypeMismatchError: () => TypeMismatchError
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../shared/src/types.ts
+var ProviderEvents = /* @__PURE__ */ ((ProviderEvents2) => {
+  ProviderEvents2["Ready"] = "PROVIDER_READY";
+  ProviderEvents2["Error"] = "PROVIDER_ERROR";
+  ProviderEvents2["ConfigurationChanged"] = "PROVIDER_CONFIGURATION_CHANGED";
+  ProviderEvents2["Shutdown"] = "PROVIDER_SHUTDOWN";
+  return ProviderEvents2;
+})(ProviderEvents || {});
+var ApiEvents = /* @__PURE__ */ ((ApiEvents2) => {
+  ApiEvents2["ProviderChanged"] = "providerChanged";
+  return ApiEvents2;
+})(ApiEvents || {});
+var StandardResolutionReasons = {
+  /**
+   * The resolved value was the result of a dynamic evaluation, such as a rule or specific user-targeting.
+   */
+  TARGETING_MATCH: "TARGETING_MATCH",
+  /**
+   * The resolved value was the result of pseudorandom assignment.
+   */
+  SPLIT: "SPLIT",
+  /**
+   * The resolved value was the result of the flag being disabled in the management system.
+   */
+  DISABLED: "DISABLED",
+  /**
+   * 	The resolved value was configured statically, or otherwise fell back to a pre-configured value.
+   */
+  DEFAULT: "DEFAULT",
+  /**
+   * The reason for the resolved value could not be determined.
+   */
+  UNKNOWN: "UNKNOWN",
+  /**
+   * The resolved value is static (no dynamic evaluation).
+   */
+  STATIC: "STATIC",
+  /**
+   * The resolved value was retrieved from cache.
+   */
+  CACHED: "CACHED",
+  /**
+   * The resolved value was the result of an error.
+   *
+   * Note: The `errorCode` and `errorMessage` fields may contain additional details of this error.
+   */
+  ERROR: "ERROR"
+};
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["PROVIDER_NOT_READY"] = "PROVIDER_NOT_READY";
+  ErrorCode2["FLAG_NOT_FOUND"] = "FLAG_NOT_FOUND";
+  ErrorCode2["PARSE_ERROR"] = "PARSE_ERROR";
+  ErrorCode2["TYPE_MISMATCH"] = "TYPE_MISMATCH";
+  ErrorCode2["TARGETING_KEY_MISSING"] = "TARGETING_KEY_MISSING";
+  ErrorCode2["INVALID_CONTEXT"] = "INVALID_CONTEXT";
+  ErrorCode2["GENERAL"] = "GENERAL";
+  return ErrorCode2;
+})(ErrorCode || {});
+
+// ../shared/src/errors/open-feature-error-abstract.ts
+var OpenFeatureError = class extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, OpenFeatureError.prototype);
+    this.name = "OpenFeatureError";
+  }
+};
+
+// ../shared/src/errors/general-error.ts
+var GeneralError = class extends OpenFeatureError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, GeneralError.prototype);
+    this.name = "GeneralError";
+    this.code = "GENERAL" /* GENERAL */;
+  }
+};
+
+// ../shared/src/errors/flag-not-found-error.ts
+var FlagNotFoundError = class extends OpenFeatureError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, FlagNotFoundError.prototype);
+    this.name = "FlagNotFoundError";
+    this.code = "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */;
+  }
+};
+
+// ../shared/src/errors/parse-error.ts
+var ParseError = class extends OpenFeatureError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, ParseError.prototype);
+    this.name = "ParseError";
+    this.code = "PARSE_ERROR" /* PARSE_ERROR */;
+  }
+};
+
+// ../shared/src/errors/type-mismatch-error.ts
+var TypeMismatchError = class extends OpenFeatureError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, TypeMismatchError.prototype);
+    this.name = "TypeMismatchError";
+    this.code = "TYPE_MISMATCH" /* TYPE_MISMATCH */;
+  }
+};
+
+// ../shared/src/errors/targeting-key-missing-error.ts
+var TargetingKeyMissingError = class extends OpenFeatureError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, TargetingKeyMissingError.prototype);
+    this.name = "TargetingKeyMissingError";
+    this.code = "TARGETING_KEY_MISSING" /* TARGETING_KEY_MISSING */;
+  }
+};
+
+// ../shared/src/errors/invalid-context-error.ts
+var InvalidContextError = class extends OpenFeatureError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, InvalidContextError.prototype);
+    this.name = "InvalidContextError";
+    this.code = "INVALID_CONTEXT" /* INVALID_CONTEXT */;
+  }
+};
+
+// ../shared/src/logger.ts
+var LOG_LEVELS = ["error", "warn", "info", "debug"];
+var DefaultLogger = class {
+  error(...args) {
+    console.error(...args);
+  }
+  warn(...args) {
+    console.warn(...args);
+  }
+  info() {
+  }
+  debug() {
+  }
+};
+var SafeLogger = class {
+  constructor(logger) {
+    this.fallbackLogger = new DefaultLogger();
+    try {
+      for (const level of LOG_LEVELS) {
+        if (!logger[level] || typeof logger[level] !== "function") {
+          throw new Error(`The provided logger is missing the ${level} method.`);
+        }
+      }
+      this.logger = logger;
+    } catch (err) {
+      console.error(err);
+      console.error("Falling back to the default logger.");
+      this.logger = this.fallbackLogger;
+    }
+  }
+  error(...args) {
+    this.log("error", ...args);
+  }
+  warn(...args) {
+    this.log("warn", ...args);
+  }
+  info(...args) {
+    this.log("info", ...args);
+  }
+  debug(...args) {
+    this.log("debug", ...args);
+  }
+  log(level, ...args) {
+    try {
+      this.logger[level](...args);
+    } catch (error) {
+      this.fallbackLogger[level](...args);
+    }
+  }
+};
+
+// ../shared/src/no-op-transaction-context-propagator.ts
+var NoopTransactionContextPropagator = class {
+  getTransactionContext() {
+    return {};
+  }
+  setTransactionContext(_, callback) {
+    callback();
+  }
+};
+var NOOP_TRANSACTION_CONTEXT_PROPAGATOR = new NoopTransactionContextPropagator();
+
+// ../shared/src/open-feature.ts
+var OpenFeatureCommonAPI = class {
+  constructor() {
+    this._transactionContextPropagator = NOOP_TRANSACTION_CONTEXT_PROPAGATOR;
+    this._context = {};
+    this._logger = new DefaultLogger();
+  }
+  getContext() {
+    return this._context;
+  }
+  setTransactionContextPropagator(transactionContextPropagator) {
+    const baseMessage = "Invalid TransactionContextPropagator, will not be set: ";
+    if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.getTransactionContext) !== "function") {
+      this._logger.error(`${baseMessage}: getTransactionContext is not a function.`);
+    } else if (typeof (transactionContextPropagator == null ? void 0 : transactionContextPropagator.setTransactionContext) !== "function") {
+      this._logger.error(`${baseMessage}: setTransactionContext is not a function.`);
+    } else {
+      this._transactionContextPropagator = transactionContextPropagator;
+    }
+    return this;
+  }
+  setTransactionContext(transactionContext, callback, ...args) {
+    this._transactionContextPropagator.setTransactionContext(transactionContext, callback, ...args);
+  }
+  getTransactionContext() {
+    try {
+      return this._transactionContextPropagator.getTransactionContext();
+    } catch (err) {
+      const error = err;
+      this._logger.error(`Error getting transaction context: ${error == null ? void 0 : error.message}, returning empty context.`);
+      this._logger.error(error == null ? void 0 : error.stack);
+      return {};
+    }
+  }
+};
+
+// src/no-op-provider.ts
+var REASON_NO_OP = "No-op";
+var NoopFeatureProvider = class {
+  constructor() {
+    this.metadata = {
+      name: "No-op Provider"
+    };
+  }
+  resolveBooleanEvaluation(_, defaultValue) {
+    return this.noOp(defaultValue);
+  }
+  resolveStringEvaluation(_, defaultValue) {
+    return this.noOp(defaultValue);
+  }
+  resolveNumberEvaluation(_, defaultValue) {
+    return this.noOp(defaultValue);
+  }
+  resolveObjectEvaluation(_, defaultValue) {
+    return this.noOp(defaultValue);
+  }
+  noOp(defaultValue) {
+    return {
+      value: defaultValue,
+      reason: REASON_NO_OP
+    };
+  }
+};
+var NOOP_PROVIDER = new NoopFeatureProvider();
+
+// src/open-feature.ts
+var GLOBAL_OPENFEATURE_API_KEY = Symbol.for("@openfeature/js.api");
+var _globalThis = globalThis;
+var OpenFeatureAPI = class extends OpenFeatureCommonAPI {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+    super();
+    this._hooks = [];
+    this._provider = NOOP_PROVIDER;
+  }
+  /**
+   * Gets a singleton instance of the OpenFeature API.
+   *
+   * @ignore
+   * @returns {OpenFeatureAPI} OpenFeature API
+   */
+  static getInstance() {
+    const globalApi = _globalThis[GLOBAL_OPENFEATURE_API_KEY];
+    if (globalApi) {
+      return globalApi;
+    }
+    const instance = new OpenFeatureAPI();
+    _globalThis[GLOBAL_OPENFEATURE_API_KEY] = instance;
+    return instance;
+  }
+  /**
+   * Get metadata about registered provider.
+   *
+   * @returns {ProviderMetadata} Provider Metadata
+   */
+  get providerMetadata() {
+    return this._provider.metadata;
+  }
+  setLogger(logger) {
+    this._logger = new SafeLogger(logger);
+    return this;
+  }
+  addHooks(...hooks) {
+    this._hooks = [...this._hooks, ...hooks];
+    return this;
+  }
+  getHooks() {
+    return this._hooks;
+  }
+  clearHooks() {
+    this._hooks = [];
+    return this;
+  }
+  setContext(context) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const oldContext = this._context;
+      this._context = context;
+      yield (_b = (_a = this._provider) == null ? void 0 : _a.onContextChange) == null ? void 0 : _b.call(_a, oldContext, context);
+    });
+  }
+  setProvider(provider) {
+    var _a;
+    if (this._provider !== provider) {
+      const oldProvider = this._provider;
+      this._provider = provider;
+      window.dispatchEvent(new CustomEvent("providerChanged" /* ProviderChanged */));
+      (_a = oldProvider == null ? void 0 : oldProvider.onClose) == null ? void 0 : _a.call(oldProvider);
+    }
+    return this;
+  }
+  close() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      yield (_b = (_a = this == null ? void 0 : this._provider) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
+    });
+  }
+  getClient(name, version, context) {
+    return new OpenFeatureClient(
+      () => this._provider,
+      () => this._logger,
+      { name, version },
+      context
+    );
+  }
+};
+var OpenFeature = OpenFeatureAPI.getInstance();
+
+// src/client.ts
+var OpenFeatureClient = class {
+  constructor(providerAccessor, globalLogger, options, context = {}) {
+    this.providerAccessor = providerAccessor;
+    this.globalLogger = globalLogger;
+    this._hooks = [];
+    this._handlerWrappers = [];
+    this.metadata = {
+      name: options.name,
+      version: options.version
+    };
+    this._context = context;
+    this.attachListeners();
+    window.dispatchEvent(new CustomEvent("providerChanged" /* ProviderChanged */));
+  }
+  addHandler(eventType, handler) {
+    this._handlerWrappers.push({ eventType, handler });
+    if (eventType === "PROVIDER_READY" /* Ready */ && this.providerAccessor().ready) {
+      handler();
+    }
+  }
+  setLogger(logger) {
+    this._clientLogger = new SafeLogger(logger);
+    return this;
+  }
+  addHooks(...hooks) {
+    this._hooks = [...this._hooks, ...hooks];
+    return this;
+  }
+  getHooks() {
+    return this._hooks;
+  }
+  clearHooks() {
+    this._hooks = [];
+    return this;
+  }
+  getBooleanValue(flagKey, defaultValue, context, options) {
+    return this.getBooleanDetails(flagKey, defaultValue, context, options).value;
+  }
+  getBooleanDetails(flagKey, defaultValue, context, options) {
+    return this.evaluate(
+      flagKey,
+      this._provider.resolveBooleanEvaluation,
+      defaultValue,
+      "boolean",
+      context,
+      options
+    );
+  }
+  getStringValue(flagKey, defaultValue, context, options) {
+    return this.getStringDetails(flagKey, defaultValue, context, options).value;
+  }
+  getStringDetails(flagKey, defaultValue, context, options) {
+    return this.evaluate(
+      flagKey,
+      // this isolates providers from our restricted string generic argument.
+      this._provider.resolveStringEvaluation,
+      defaultValue,
+      "string",
+      context,
+      options
+    );
+  }
+  getNumberValue(flagKey, defaultValue, context, options) {
+    return this.getNumberDetails(flagKey, defaultValue, context, options).value;
+  }
+  getNumberDetails(flagKey, defaultValue, context, options) {
+    return this.evaluate(
+      flagKey,
+      // this isolates providers from our restricted number generic argument.
+      this._provider.resolveNumberEvaluation,
+      defaultValue,
+      "number",
+      context,
+      options
+    );
+  }
+  getObjectValue(flagKey, defaultValue, context, options) {
+    return this.getObjectDetails(flagKey, defaultValue, context, options).value;
+  }
+  getObjectDetails(flagKey, defaultValue, context, options) {
+    return this.evaluate(flagKey, this._provider.resolveObjectEvaluation, defaultValue, "object", context, options);
+  }
+  evaluate(flagKey, resolver, defaultValue, flagType, invocationContext = {}, options = {}) {
+    const allHooks = [
+      ...OpenFeature.getHooks(),
+      ...this.getHooks(),
+      ...options.hooks || [],
+      ...this._provider.hooks || []
+    ];
+    const allHooksReversed = [...allHooks].reverse();
+    const mergedContext = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, OpenFeature.getContext()), OpenFeature.getTransactionContext()), this._context), invocationContext);
+    const hookContext = {
+      flagKey,
+      defaultValue,
+      flagValueType: flagType,
+      clientMetadata: this.metadata,
+      providerMetadata: OpenFeature.providerMetadata,
+      context: mergedContext,
+      logger: this._logger
+    };
+    try {
+      const frozenContext = this.beforeHooks(allHooks, hookContext, options);
+      const resolution = resolver.call(this._provider, flagKey, defaultValue, frozenContext, this._logger);
+      const evaluationDetails = __spreadProps(__spreadValues({}, resolution), {
+        flagKey
+      });
+      this.afterHooks(allHooksReversed, hookContext, evaluationDetails, options);
+      return evaluationDetails;
+    } catch (err) {
+      const errorMessage = err == null ? void 0 : err.message;
+      const errorCode = (err == null ? void 0 : err.code) || "GENERAL" /* GENERAL */;
+      this.errorHooks(allHooksReversed, hookContext, err, options);
+      return {
+        errorCode,
+        errorMessage,
+        value: defaultValue,
+        reason: StandardResolutionReasons.ERROR,
+        flagKey
+      };
+    } finally {
+      this.finallyHooks(allHooksReversed, hookContext, options);
+    }
+  }
+  beforeHooks(hooks, hookContext, options) {
+    var _a;
+    for (const hook of hooks) {
+      Object.freeze(hookContext);
+      Object.assign(hookContext.context, __spreadValues(__spreadValues({}, hookContext.context), (_a = hook == null ? void 0 : hook.before) == null ? void 0 : _a.call(hook, hookContext, Object.freeze(options.hookHints))));
+    }
+    return Object.freeze(hookContext.context);
+  }
+  afterHooks(hooks, hookContext, evaluationDetails, options) {
+    var _a;
+    for (const hook of hooks) {
+      (_a = hook == null ? void 0 : hook.after) == null ? void 0 : _a.call(hook, hookContext, evaluationDetails, options.hookHints);
+    }
+  }
+  errorHooks(hooks, hookContext, err, options) {
+    var _a;
+    for (const hook of hooks) {
+      try {
+        (_a = hook == null ? void 0 : hook.error) == null ? void 0 : _a.call(hook, hookContext, err, options.hookHints);
+      } catch (err2) {
+        this._logger.error(`Unhandled error during 'error' hook: ${err2}`);
+        if (err2 instanceof Error) {
+          this._logger.error(err2.stack);
+        }
+        this._logger.error(err2 == null ? void 0 : err2.stack);
+      }
+    }
+  }
+  finallyHooks(hooks, hookContext, options) {
+    var _a;
+    for (const hook of hooks) {
+      try {
+        (_a = hook == null ? void 0 : hook.finally) == null ? void 0 : _a.call(hook, hookContext, options.hookHints);
+      } catch (err) {
+        this._logger.error(`Unhandled error during 'finally' hook: ${err}`);
+        if (err instanceof Error) {
+          this._logger.error(err.stack);
+        }
+        this._logger.error(err == null ? void 0 : err.stack);
+      }
+    }
+  }
+  get _provider() {
+    return this.providerAccessor();
+  }
+  get _logger() {
+    return this._clientLogger || this.globalLogger();
+  }
+  attachListeners() {
+    Object.values(ProviderEvents).forEach((eventType) => window.addEventListener(eventType, () => {
+      this._handlerWrappers.filter((wrapper) => wrapper.eventType === eventType).forEach((wrapper) => wrapper.handler());
+    }));
+  }
+};
+//# sourceMappingURL=index.js.map