@croct/sdk 0.17.8 → 0.17.10

package/contentFetcher.cjs

@@ -0,0 +1,193 @@
+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);
+var contentFetcher_exports = {};
+__export(contentFetcher_exports, {
+  ContentError: () => ContentError,
+  ContentErrorType: () => ContentErrorType,
+  ContentFetcher: () => ContentFetcher
+});
+module.exports = __toCommonJS(contentFetcher_exports);
+var import_constants = require("./constants");
+var import_error = require("./error");
+var import_logging = require("./logging");
+var import_help = require("./help");
+var ContentErrorType = /* @__PURE__ */ ((ContentErrorType2) => {
+  ContentErrorType2["TIMEOUT"] = "https://croct.help/api/content#timeout";
+  ContentErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/content#unexpected-error";
+  return ContentErrorType2;
+})(ContentErrorType || {});
+class ContentError extends Error {
+  constructor(response) {
+    super(response.title);
+    this.response = response;
+    Object.setPrototypeOf(this, ContentError.prototype);
+  }
+}
+class ContentFetcher {
+  constructor(configuration) {
+    if (configuration.appId === void 0 === (configuration.apiKey === void 0)) {
+      throw new Error("Either the application ID or the API key must be provided.");
+    }
+    const { baseEndpointUrl } = configuration;
+    const apiKey = typeof configuration.apiKey === "object" ? configuration.apiKey.getIdentifier() : configuration.apiKey;
+    const baseEndpoint = (baseEndpointUrl ?? import_constants.BASE_ENDPOINT_URL).replace(/\/+$/, "") + (apiKey === void 0 ? "/client" : "/external") + "/web";
+    this.dynamicEndpoint = `${baseEndpoint}/content`;
+    this.staticEndpoint = `${baseEndpoint}/static-content`;
+    this.logger = configuration.logger ?? new import_logging.NullLogger();
+    this.configuration = {
+      appId: configuration.appId,
+      apiKey,
+      defaultTimeout: configuration.defaultTimeout,
+      defaultPreferredLocale: configuration.defaultPreferredLocale
+    };
+  }
+  fetch(slotId, options = {}) {
+    if (options.static === true && this.configuration.apiKey === void 0) {
+      throw new Error("The API key must be provided to fetch static content.");
+    }
+    return new Promise((resolve, reject) => {
+      const abortController = new AbortController();
+      const timeout = options.timeout ?? this.configuration.defaultTimeout;
+      let timer;
+      if (timeout !== void 0) {
+        timer = setTimeout(
+          () => {
+            const response = {
+              title: `Content could not be loaded in time for slot '${slotId}'.`,
+              type: "https://croct.help/api/content#timeout" /* TIMEOUT */,
+              detail: `The content took more than ${timeout}ms to load.`,
+              status: 408
+              // Request Timeout
+            };
+            abortController.abort();
+            this.logHelp(response.status);
+            reject(new ContentError(response));
+          },
+          timeout
+        );
+      }
+      this.load(slotId, abortController.signal, options).finally(() => clearTimeout(timer)).then((response) => {
+        const region = response.headers.get("X-Croct-Region");
+        const timing = response.headers.get("X-Croct-Timing");
+        this.logger.debug(`Content for slot '${slotId}' processed by region ${region} in ${timing}.`);
+        return response.json().then((body) => {
+          if (response.ok) {
+            return resolve(body);
+          }
+          this.logHelp(response.status);
+          reject(new ContentError(body));
+        }).catch((error) => {
+          if (!response.ok) {
+            throw new Error(`Error ${response.status} - ${response.statusText}`);
+          }
+          throw error;
+        });
+      }).catch((error) => {
+        if (!abortController.signal.aborted) {
+          reject(
+            new ContentError({
+              title: (0, import_error.formatMessage)(error),
+              type: "https://croct.help/api/content#unexpected-error" /* UNEXPECTED_ERROR */,
+              detail: "Please try again or contact Croct support if the error persists.",
+              status: 500
+              // Internal Server Error
+            })
+          );
+        }
+      });
+    });
+  }
+  load(slotId, signal, options) {
+    const { apiKey, appId } = this.configuration;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    headers["X-Client-Library"] = import_constants.CLIENT_LIBRARY;
+    if (appId !== void 0) {
+      headers["X-App-Id"] = appId;
+    }
+    if (apiKey !== void 0) {
+      headers["X-Api-Key"] = apiKey;
+    }
+    const payload = {
+      slotId
+    };
+    if (options.version !== void 0) {
+      payload.version = `${options.version}`;
+    }
+    const preferredLocale = options.preferredLocale ?? this.configuration.defaultPreferredLocale;
+    if (preferredLocale !== void 0) {
+      payload.preferredLocale = preferredLocale;
+    }
+    const dynamic = ContentFetcher.isDynamicContent(options);
+    if (dynamic) {
+      if (options.clientId !== void 0) {
+        headers["X-Client-Id"] = options.clientId;
+      }
+      if (options.clientIp !== void 0) {
+        headers["X-Client-Ip"] = options.clientIp;
+      }
+      if (options.userToken !== void 0) {
+        headers["X-Token"] = options.userToken.toString();
+      }
+      if (options.clientAgent !== void 0) {
+        headers["X-Client-Agent"] = options.clientAgent;
+      }
+      if (options.context !== void 0) {
+        payload.context = options.context;
+      }
+      if (options.previewToken !== void 0) {
+        payload.previewToken = `${options.previewToken}`;
+      }
+    }
+    return fetch(dynamic ? this.dynamicEndpoint : this.staticEndpoint, {
+      // Set the request mode to 'cors' when running in the browser.
+      // By default, the request mode is computed based on the referrer policy
+      // and response-tainting rules applied to the script that ultimately
+      // initiated the fetch, make this prone to errors due to unrelated
+      // configurations on the page.
+      // https://fetch.spec.whatwg.org/#origin-header
+      mode: typeof window === "undefined" ? void 0 : "cors",
+      credentials: "omit",
+      ...options.extra,
+      method: "POST",
+      headers,
+      signal,
+      body: JSON.stringify(payload)
+    });
+  }
+  logHelp(statusCode) {
+    const help = import_help.Help.forStatusCode(statusCode);
+    if (help !== void 0) {
+      this.logger.error(help);
+    }
+  }
+  static isDynamicContent(options) {
+    return options.static !== true;
+  }
+  toJSON() {
+    throw new Error("Unserializable value.");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentError,
+  ContentErrorType,
+  ContentFetcher
+});
+//# sourceMappingURL=contentFetcher.cjs.map

package/context.cjs

@@ -0,0 +1,114 @@
+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);
+var context_exports = {};
+__export(context_exports, {
+  Context: () => Context
+});
+module.exports = __toCommonJS(context_exports);
+var import_token = require("./token");
+var import_tab = require("./tab");
+var import_uuid = require("./uuid");
+var import_cache = require("./cache");
+function tokenEquals(left, right) {
+  return left === right || left !== null && right !== null && left.toString() === right.toString();
+}
+class Context {
+  constructor(tab, tokenStore, eventDispatcher) {
+    this.tab = tab;
+    this.tokenStore = tokenStore;
+    this.eventDispatcher = eventDispatcher;
+    this.lastToken = tokenStore.getToken();
+    this.syncToken = this.syncToken.bind(this);
+  }
+  static load({ cache, tokenScope, eventDispatcher, urlSanitizer }) {
+    let tabId = cache.tabId.get();
+    let newTab = false;
+    if (tabId === null) {
+      tabId = (0, import_uuid.uuid4)(true);
+      newTab = true;
+    }
+    const tab = new import_tab.Tab(tabId, newTab, urlSanitizer);
+    cache.tabId.clear();
+    tab.addListener("unload", () => cache.tabId.put(tab.id));
+    switch (tokenScope) {
+      case "isolated":
+        return new Context(tab, new import_token.InMemoryTokenStore(), eventDispatcher);
+      case "global": {
+        const context = new Context(tab, new import_token.CachedTokenStore(cache.browserToken), eventDispatcher);
+        if (import_cache.ObservableCache.isObservable(cache.browserToken)) {
+          cache.browserToken.addListener(context.syncToken);
+        }
+        return context;
+      }
+      case "contextual": {
+        const primaryStorage = new import_token.CachedTokenStore(cache.tabToken);
+        const secondaryStorage = new import_token.CachedTokenStore(cache.browserToken);
+        if (tab.isNew) {
+          primaryStorage.setToken(secondaryStorage.getToken());
+        }
+        tab.addListener("visibilityChange", (event) => {
+          if (event.detail.visible) {
+            secondaryStorage.setToken(primaryStorage.getToken());
+          }
+        });
+        return new Context(tab, new import_token.ReplicatedTokenStore(primaryStorage, secondaryStorage), eventDispatcher);
+      }
+    }
+  }
+  getTab() {
+    return this.tab;
+  }
+  isAnonymous() {
+    const token = this.getToken();
+    return token == null || token.isAnonymous();
+  }
+  getUser() {
+    const token = this.getToken();
+    return token == null ? null : token.getSubject();
+  }
+  getToken() {
+    return this.tokenStore.getToken();
+  }
+  setToken(token) {
+    const oldToken = this.lastToken;
+    this.lastToken = token;
+    this.tokenStore.setToken(token);
+    if (!tokenEquals(oldToken, token)) {
+      this.eventDispatcher.dispatch("tokenChanged", {
+        oldToken,
+        newToken: token
+      });
+    }
+  }
+  syncToken() {
+    const newToken = this.tokenStore.getToken();
+    const oldToken = this.lastToken;
+    if (!tokenEquals(oldToken, newToken)) {
+      this.lastToken = newToken;
+      this.eventDispatcher.dispatch("tokenChanged", {
+        oldToken,
+        newToken
+      });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context
+});
+//# sourceMappingURL=context.cjs.map

package/error.cjs

@@ -0,0 +1,52 @@
+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);
+var error_exports = {};
+__export(error_exports, {
+  formatCause: () => formatCause,
+  formatMessage: () => formatMessage
+});
+module.exports = __toCommonJS(error_exports);
+function extractMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string" && error !== "") {
+    return error;
+  }
+  return "unknown error";
+}
+function formatMessage(error) {
+  const message = extractMessage(error);
+  if (message.length === 0) {
+    return message;
+  }
+  return message.charAt(0).toUpperCase() + message.slice(1);
+}
+function formatCause(error) {
+  const message = formatMessage(error);
+  if (message.length === 0) {
+    return message;
+  }
+  return message.charAt(0).toLowerCase() + message.slice(1);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatCause,
+  formatMessage
+});
+//# sourceMappingURL=error.cjs.map

package/evaluator.cjs

@@ -0,0 +1,219 @@
+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);
+var evaluator_exports = {};
+__export(evaluator_exports, {
+  EvaluationError: () => EvaluationError,
+  EvaluationErrorType: () => EvaluationErrorType,
+  Evaluator: () => Evaluator,
+  QueryError: () => QueryError
+});
+module.exports = __toCommonJS(evaluator_exports);
+var import_constants = require("./constants");
+var import_error = require("./error");
+var import_sourceLocation = require("./sourceLocation");
+var import_logging = require("./logging");
+var import_help = require("./help");
+var EvaluationErrorType = /* @__PURE__ */ ((EvaluationErrorType2) => {
+  EvaluationErrorType2["TIMEOUT"] = "https://croct.help/api/evaluation#timeout";
+  EvaluationErrorType2["UNEXPECTED_ERROR"] = "https://croct.help/api/evaluation#unexpected-error";
+  EvaluationErrorType2["INVALID_QUERY"] = "https://croct.help/api/evaluation#invalid-query";
+  EvaluationErrorType2["TOO_COMPLEX_QUERY"] = "https://croct.help/api/evaluation#too-complex-query";
+  EvaluationErrorType2["EVALUATION_FAILED"] = "https://croct.help/api/evaluation#evaluation-failed";
+  EvaluationErrorType2["UNALLOWED_RESULT"] = "https://croct.help/api/evaluation#unallowed-result";
+  EvaluationErrorType2["UNSERIALIZABLE_RESULT"] = "https://croct.help/api/evaluation#unserializable-result";
+  return EvaluationErrorType2;
+})(EvaluationErrorType || {});
+class EvaluationError extends Error {
+  constructor(response) {
+    super(response.title);
+    this.response = response;
+    Object.setPrototypeOf(this, EvaluationError.prototype);
+  }
+}
+class QueryError extends EvaluationError {
+  constructor(response) {
+    super(response);
+    Object.setPrototypeOf(this, QueryError.prototype);
+  }
+}
+const _Evaluator = class _Evaluator {
+  constructor(configuration) {
+    if (configuration.appId === void 0 === (configuration.apiKey === void 0)) {
+      throw new Error("Either the application ID or the API key must be provided.");
+    }
+    const { baseEndpointUrl } = configuration;
+    const apiKey = typeof configuration.apiKey === "object" ? configuration.apiKey.getIdentifier() : configuration.apiKey;
+    this.endpoint = (baseEndpointUrl ?? import_constants.BASE_ENDPOINT_URL).replace(/\/+$/, "") + (apiKey === void 0 ? "/client" : "/external") + "/web/evaluate";
+    this.logger = configuration.logger ?? new import_logging.NullLogger();
+    this.configuration = {
+      appId: configuration.appId,
+      apiKey,
+      defaultTimeout: configuration.defaultTimeout
+    };
+  }
+  evaluate(query, options = {}) {
+    const length = (0, import_sourceLocation.getLength)(query);
+    const reference = query.length > 20 ? `${query.slice(0, 20)}...` : query;
+    if (length > _Evaluator.MAX_QUERY_LENGTH) {
+      const response = {
+        title: "The query is too complex.",
+        status: 422,
+        // Unprocessable Entity
+        type: "https://croct.help/api/evaluation#too-complex-query" /* TOO_COMPLEX_QUERY */,
+        detail: `The query "${reference}" must be at most ${_Evaluator.MAX_QUERY_LENGTH} characters long, but it is ${length} characters long.`,
+        errors: [{
+          cause: "The query is longer than expected.",
+          location: (0, import_sourceLocation.getLocation)(query, 0, Math.max(length - 1, 0))
+        }]
+      };
+      return Promise.reject(new QueryError(response));
+    }
+    const payload = {
+      query
+    };
+    if (options.context !== void 0) {
+      payload.context = options.context;
+    }
+    return new Promise((resolve, reject) => {
+      const abortController = new AbortController();
+      const timeout = options.timeout ?? this.configuration.defaultTimeout;
+      let timer;
+      if (timeout !== void 0) {
+        timer = setTimeout(
+          () => {
+            const response = {
+              title: `Evaluation could not be completed in time for query "${reference}".`,
+              type: "https://croct.help/api/evaluation#timeout" /* TIMEOUT */,
+              detail: `The evaluation took more than ${timeout}ms to complete.`,
+              status: 408
+              // Request Timeout
+            };
+            abortController.abort();
+            this.logHelp(response.status);
+            reject(new EvaluationError(response));
+          },
+          timeout
+        );
+      }
+      this.fetch(payload, abortController.signal, options).finally(() => clearTimeout(timer)).then(
+        (response) => {
+          const region = response.headers.get("X-Croct-Region");
+          const timing = response.headers.get("X-Croct-Timing");
+          this.logger.debug(
+            `Evaluation of the query "${reference}" processed by region ${region} in ${timing}.`
+          );
+          return response.json().then((body) => {
+            if (response.ok) {
+              return resolve(body);
+            }
+            this.logHelp(response.status);
+            const problem = body;
+            switch (problem.type) {
+              case "https://croct.help/api/evaluation#invalid-query" /* INVALID_QUERY */:
+              case "https://croct.help/api/evaluation#evaluation-failed" /* EVALUATION_FAILED */:
+              case "https://croct.help/api/evaluation#too-complex-query" /* TOO_COMPLEX_QUERY */:
+                reject(new QueryError(problem));
+                break;
+              default:
+                reject(new EvaluationError(problem));
+                break;
+            }
+          }).catch((error) => {
+            if (!response.ok) {
+              throw new Error(`Error ${response.status} - ${response.statusText}`);
+            }
+            throw error;
+          });
+        }
+      ).catch(
+        (error) => {
+          if (!abortController.signal.aborted) {
+            reject(
+              new EvaluationError({
+                title: (0, import_error.formatMessage)(error),
+                type: "https://croct.help/api/evaluation#unexpected-error" /* UNEXPECTED_ERROR */,
+                detail: "Please try again or contact Croct support if the error persists.",
+                status: 500
+                // Internal Server Error
+              })
+            );
+          }
+        }
+      );
+    });
+  }
+  fetch(body, signal, options) {
+    const { appId, apiKey } = this.configuration;
+    const { clientId, clientIp, userToken, clientAgent } = options;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    headers["X-Client-Library"] = import_constants.CLIENT_LIBRARY;
+    if (apiKey !== void 0) {
+      headers["X-Api-Key"] = apiKey;
+    } else if (appId !== void 0) {
+      headers["X-App-Id"] = appId;
+    }
+    if (clientId !== void 0) {
+      headers["X-Client-Id"] = clientId;
+    }
+    if (clientIp !== void 0) {
+      headers["X-Client-Ip"] = clientIp;
+    }
+    if (userToken !== void 0) {
+      headers["X-Token"] = userToken.toString();
+    }
+    if (clientAgent !== void 0) {
+      headers["X-Client-Agent"] = clientAgent;
+    }
+    return fetch(this.endpoint, {
+      // Set the request mode to 'cors' when running in the browser.
+      // By default, the request mode is computed based on the referrer policy
+      // and response-tainting rules applied to the script that ultimately
+      // initiated the fetch, make this prone to errors due to unrelated
+      // configurations on the page.
+      // https://fetch.spec.whatwg.org/#origin-header
+      mode: typeof window === "undefined" ? void 0 : "cors",
+      credentials: "omit",
+      ...options.extra,
+      method: "POST",
+      headers,
+      signal,
+      body: JSON.stringify(body)
+    });
+  }
+  logHelp(statusCode) {
+    const help = import_help.Help.forStatusCode(statusCode);
+    if (help !== void 0) {
+      this.logger.error(help);
+    }
+  }
+  toJSON() {
+    throw new Error("Unserializable value.");
+  }
+};
+_Evaluator.MAX_QUERY_LENGTH = import_constants.MAX_QUERY_LENGTH;
+let Evaluator = _Evaluator;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvaluationError,
+  EvaluationErrorType,
+  Evaluator,
+  QueryError
+});
+//# sourceMappingURL=evaluator.cjs.map

package/eventManager.cjs

@@ -0,0 +1,53 @@
+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);
+var eventManager_exports = {};
+__export(eventManager_exports, {
+  SynchronousEventManager: () => SynchronousEventManager
+});
+module.exports = __toCommonJS(eventManager_exports);
+class SynchronousEventManager {
+  constructor() {
+    this.listeners = {};
+  }
+  addListener(type, listener) {
+    const listeners = this.listeners[type] ?? [];
+    listeners.push(listener);
+    this.listeners[type] = listeners;
+  }
+  removeListener(eventName, listener) {
+    const listeners = this.listeners[eventName];
+    if (listeners === void 0) {
+      return;
+    }
+    const index = listeners.indexOf(listener);
+    if (index >= 0) {
+      listeners.splice(index, 1);
+    }
+  }
+  dispatch(eventName, event) {
+    const listeners = this.listeners[eventName];
+    if (listeners !== void 0) {
+      listeners.forEach((listener) => listener(event));
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SynchronousEventManager
+});
+//# sourceMappingURL=eventManager.cjs.map