@croct/sdk 0.17.8 → 0.17.10

package/eventSubjectProcessor.cjs

@@ -0,0 +1,84 @@
+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 eventSubjectProcessor_exports = {};
+__export(eventSubjectProcessor_exports, {
+  EventSubjectProcessor: () => EventSubjectProcessor
+});
+module.exports = __toCommonJS(eventSubjectProcessor_exports);
+class EventSubjectProcessor {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  process(event) {
+    const { currentToken } = this;
+    this.currentToken = event.userToken ?? null;
+    if (currentToken === void 0) {
+      return [event];
+    }
+    if (EventSubjectProcessor.isIdentificationEvent(event.event)) {
+      return [event];
+    }
+    const currentSubject = currentToken?.getSubject() ?? null;
+    const newSubject = event.userToken?.getSubject() ?? null;
+    if (newSubject === currentSubject) {
+      return [event];
+    }
+    const events = [];
+    if (currentToken !== null && currentSubject !== null) {
+      this.logger.info("External user sign out automatically tracked");
+      events.push({
+        timestamp: event.timestamp,
+        context: event.context,
+        userToken: currentToken,
+        event: {
+          type: "userSignedOut",
+          userId: currentSubject
+        }
+      });
+    }
+    if (newSubject !== null) {
+      this.logger.info("External user sign in automatically tracked");
+      events.push({
+        timestamp: event.timestamp,
+        context: event.context,
+        userToken: event.userToken,
+        event: {
+          type: "userSignedIn",
+          userId: newSubject
+        }
+      });
+    }
+    events.push(event);
+    return events;
+  }
+  static isIdentificationEvent(event) {
+    switch (event.type) {
+      case "userSignedIn":
+      case "userSignedUp":
+      case "userSignedOut":
+        return true;
+      default:
+        return false;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventSubjectProcessor
+});
+//# sourceMappingURL=eventSubjectProcessor.cjs.map

package/facade/contentFetcherFacade.cjs

@@ -0,0 +1,61 @@
+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 contentFetcherFacade_exports = {};
+__export(contentFetcherFacade_exports, {
+  ContentFetcherFacade: () => ContentFetcherFacade
+});
+module.exports = __toCommonJS(contentFetcherFacade_exports);
+var import_error = require("../error");
+var import_schema = require("../schema");
+function validate(options) {
+  try {
+    import_schema.fetchOptionsSchema.validate(options);
+  } catch (violation) {
+    throw new Error(`Invalid options: ${(0, import_error.formatCause)(violation)}`);
+  }
+}
+class ContentFetcherFacade {
+  constructor(configuration) {
+    this.fetcher = configuration.contentFetcher;
+    this.previewTokenProvider = configuration.previewTokenProvider;
+    this.userTokenProvider = configuration.userTokenProvider;
+    this.cidAssigner = configuration.cidAssigner;
+    this.contextFactory = configuration.contextFactory;
+  }
+  async fetch(slotId, options = {}) {
+    if (typeof slotId !== "string" || slotId.length === 0) {
+      throw new Error("The slot ID must be a non-empty string.");
+    }
+    validate(options);
+    return this.fetcher.fetch(slotId, {
+      static: false,
+      clientId: await this.cidAssigner.assignCid(),
+      userToken: this.userTokenProvider.getToken() ?? void 0,
+      previewToken: this.previewTokenProvider.getToken() ?? void 0,
+      version: options.version,
+      context: this.contextFactory.createContext(options.attributes),
+      timeout: options.timeout,
+      preferredLocale: options.preferredLocale
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentFetcherFacade
+});
+//# sourceMappingURL=contentFetcherFacade.cjs.map

package/facade/evaluatorFacade.cjs

@@ -0,0 +1,94 @@
+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 evaluatorFacade_exports = {};
+__export(evaluatorFacade_exports, {
+  EvaluatorFacade: () => EvaluatorFacade,
+  MinimalContextFactory: () => MinimalContextFactory,
+  TabContextFactory: () => TabContextFactory
+});
+module.exports = __toCommonJS(evaluatorFacade_exports);
+var import_schema = require("../schema");
+var import_error = require("../error");
+function validate(options) {
+  try {
+    import_schema.evaluationOptionsSchema.validate(options);
+  } catch (violation) {
+    throw new Error(`Invalid options: ${(0, import_error.formatCause)(violation)}`);
+  }
+}
+class EvaluatorFacade {
+  constructor(configuration) {
+    this.evaluator = configuration.evaluator;
+    this.contextFactory = configuration.contextFactory;
+    this.tokenProvider = configuration.userTokenProvider;
+    this.cidAssigner = configuration.cidAssigner;
+  }
+  async evaluate(query, options = {}) {
+    if (typeof query !== "string" || query.length === 0) {
+      throw new Error("The query must be a non-empty string.");
+    }
+    validate(options);
+    return this.evaluator.evaluate(query, {
+      clientId: await this.cidAssigner.assignCid(),
+      userToken: this.tokenProvider.getToken() ?? void 0,
+      timeout: options.timeout,
+      context: this.contextFactory.createContext(options.attributes)
+    });
+  }
+}
+class MinimalContextFactory {
+  createContext(attributes) {
+    if (attributes === void 0) {
+      return {};
+    }
+    return { attributes };
+  }
+}
+class TabContextFactory {
+  constructor(tab) {
+    this.tab = tab;
+  }
+  createContext(attributes) {
+    const url = new URL(this.tab.url);
+    const context = {};
+    const page = {
+      title: this.tab.title,
+      url: url.toString()
+    };
+    const { referrer } = this.tab;
+    if (referrer.length > 0) {
+      page.referrer = referrer;
+    }
+    context.page = page;
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone ?? null;
+    if (timeZone !== null) {
+      context.timeZone = timeZone;
+    }
+    if (attributes !== void 0 && Object.keys(attributes).length > 0) {
+      context.attributes = attributes;
+    }
+    return context;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvaluatorFacade,
+  MinimalContextFactory,
+  TabContextFactory
+});
+//# sourceMappingURL=evaluatorFacade.cjs.map

package/facade/index.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 facade_exports = {};
+__export(facade_exports, {
+  ContextFactory: () => import_evaluatorFacade.ContextFactory,
+  EvaluatorFacade: () => import_evaluatorFacade.EvaluatorFacade,
+  MinimalContextFactory: () => import_evaluatorFacade.MinimalContextFactory,
+  SdkFacade: () => import_sdkFacade.SdkFacade,
+  SessionFacade: () => import_sessionFacade.SessionFacade,
+  SessionPatch: () => import_sessionPatch.SessionPatch,
+  TabContextFactory: () => import_evaluatorFacade.TabContextFactory,
+  TrackerFacade: () => import_trackerFacade.TrackerFacade,
+  UserFacade: () => import_userFacade.UserFacade,
+  UserPatch: () => import_userPatch.UserPatch
+});
+module.exports = __toCommonJS(facade_exports);
+var import_evaluatorFacade = require("./evaluatorFacade");
+var import_sdkFacade = require("./sdkFacade");
+var import_sessionFacade = require("./sessionFacade");
+var import_sessionPatch = require("./sessionPatch");
+var import_trackerFacade = require("./trackerFacade");
+var import_userFacade = require("./userFacade");
+var import_userPatch = require("./userPatch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextFactory,
+  EvaluatorFacade,
+  MinimalContextFactory,
+  SdkFacade,
+  SessionFacade,
+  SessionPatch,
+  TabContextFactory,
+  TrackerFacade,
+  UserFacade,
+  UserPatch
+});
+//# sourceMappingURL=index.cjs.map

package/facade/sdkFacade.cjs

@@ -0,0 +1,229 @@
+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 sdkFacade_exports = {};
+__export(sdkFacade_exports, {
+  SdkFacade: () => SdkFacade
+});
+module.exports = __toCommonJS(sdkFacade_exports);
+var import_evaluatorFacade = require("./evaluatorFacade");
+var import_trackerFacade = require("./trackerFacade");
+var import_userFacade = require("./userFacade");
+var import_token = require("../token");
+var import_error = require("../error");
+var import_schema = require("../schema");
+var import_sdk = require("../sdk");
+var import_sessionFacade = require("./sessionFacade");
+var import_contentFetcherFacade = require("./contentFetcherFacade");
+var import_eventSubjectProcessor = require("../eventSubjectProcessor");
+function validateConfiguration(configuration) {
+  try {
+    import_schema.sdkFacadeConfigurationSchema.validate(configuration);
+  } catch (violation) {
+    throw new Error(`Invalid configuration: ${(0, import_error.formatCause)(violation)}`);
+  }
+}
+class SdkFacade {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+  static init(configuration) {
+    validateConfiguration(configuration);
+    const { track = true, userId, token, ...containerConfiguration } = configuration;
+    if (userId !== void 0 && token !== void 0) {
+      throw new Error("Either the user ID or token can be specified, but not both.");
+    }
+    const sdk = new SdkFacade(
+      import_sdk.Sdk.init({
+        ...containerConfiguration,
+        tokenScope: containerConfiguration.tokenScope ?? "global",
+        debug: containerConfiguration.debug ?? false,
+        test: containerConfiguration.test ?? false,
+        disableCidMirroring: containerConfiguration.disableCidMirroring ?? false,
+        eventProcessor: (container) => new import_eventSubjectProcessor.EventSubjectProcessor(container.getLogger("EventSubjectProcessor"))
+      })
+    );
+    if (userId !== void 0) {
+      const currentToken = sdk.context.getToken();
+      const currentSubject = currentToken?.getSubject() ?? null;
+      if (currentSubject !== userId) {
+        if (userId === null) {
+          sdk.unsetToken();
+        } else {
+          sdk.identify(userId);
+        }
+      }
+    } else if (token !== void 0) {
+      if (token === null) {
+        sdk.unsetToken();
+      } else {
+        sdk.setToken(import_token.Token.parse(token));
+      }
+    }
+    if (track) {
+      sdk.tracker.enable();
+    }
+    return sdk;
+  }
+  get context() {
+    return this.sdk.context;
+  }
+  get cidAssigner() {
+    return this.sdk.cidAssigner;
+  }
+  get previewTokenStore() {
+    return this.sdk.previewTokenStore;
+  }
+  get userTokenStore() {
+    return this.sdk.userTokenStore;
+  }
+  get tracker() {
+    if (this.trackerFacade === void 0) {
+      this.trackerFacade = new import_trackerFacade.TrackerFacade(this.sdk.tracker);
+    }
+    return this.trackerFacade;
+  }
+  get user() {
+    if (this.userFacade === void 0) {
+      this.userFacade = new import_userFacade.UserFacade(this.context, this.sdk.tracker);
+    }
+    return this.userFacade;
+  }
+  get session() {
+    if (this.sessionFacade === void 0) {
+      this.sessionFacade = new import_sessionFacade.SessionFacade(this.sdk.tracker);
+    }
+    return this.sessionFacade;
+  }
+  get evaluator() {
+    if (this.evaluatorFacade === void 0) {
+      this.evaluatorFacade = new import_evaluatorFacade.EvaluatorFacade({
+        evaluator: this.sdk.evaluator,
+        contextFactory: new import_evaluatorFacade.TabContextFactory(this.sdk.context.getTab()),
+        cidAssigner: this.sdk.cidAssigner,
+        userTokenProvider: this.sdk.userTokenStore
+      });
+    }
+    return this.evaluatorFacade;
+  }
+  get contentFetcher() {
+    if (this.contentFetcherFacade === void 0) {
+      this.contentFetcherFacade = new import_contentFetcherFacade.ContentFetcherFacade({
+        contentFetcher: this.sdk.contentFetcher,
+        contextFactory: new import_evaluatorFacade.TabContextFactory(this.sdk.context.getTab()),
+        cidAssigner: this.sdk.cidAssigner,
+        previewTokenProvider: this.sdk.previewTokenStore,
+        userTokenProvider: this.sdk.userTokenStore
+      });
+    }
+    return this.contentFetcherFacade;
+  }
+  get eventManager() {
+    const { eventManager } = this.sdk;
+    return {
+      addListener: eventManager.addListener.bind(eventManager),
+      removeListener: eventManager.removeListener.bind(eventManager),
+      dispatch: (eventName, event) => {
+        if (!/[a-z][a-z_]+\.[a-z][a-z_]+/i.test(eventName)) {
+          throw new Error(
+            'The event name must be in the form of "namespaced.eventName", where both the namespace and event name must start with a letter, followed by any series of letters and underscores.'
+          );
+        }
+        eventManager.dispatch(eventName, event);
+      }
+    };
+  }
+  identify(userId) {
+    this.setToken(import_token.Token.issue(this.sdk.appId, userId));
+  }
+  anonymize() {
+    if (!this.context.isAnonymous()) {
+      this.unsetToken();
+    }
+  }
+  getToken() {
+    return this.context.getToken();
+  }
+  setToken(token) {
+    const currentToken = this.getToken();
+    if (currentToken !== null && currentToken.toString() === token.toString()) {
+      return;
+    }
+    const currentSubject = currentToken?.getSubject() ?? null;
+    const subject = token.getSubject();
+    const logger = this.getLogger();
+    if (subject === currentSubject) {
+      this.context.setToken(token);
+      logger.debug("Token refreshed");
+      return;
+    }
+    if (currentSubject !== null) {
+      this.trackInternalEvent({
+        type: "userSignedOut",
+        userId: currentSubject
+      });
+      logger.info("User signed out");
+    }
+    this.context.setToken(token);
+    if (subject !== null) {
+      this.trackInternalEvent({
+        type: "userSignedIn",
+        userId: subject
+      });
+      logger.info(`User signed in as ${subject}`);
+    }
+    logger.debug("New token saved, ");
+  }
+  unsetToken() {
+    const token = this.getToken();
+    if (token === null) {
+      return;
+    }
+    const logger = this.getLogger();
+    const subject = token.getSubject();
+    if (subject !== null) {
+      this.trackInternalEvent({
+        type: "userSignedOut",
+        userId: subject
+      });
+      logger.info("User signed out");
+    }
+    this.context.setToken(null);
+    logger.debug("Token removed");
+  }
+  trackInternalEvent(event) {
+    this.sdk.tracker.track(event).catch(() => {
+    });
+  }
+  getLogger(...namespace) {
+    return this.sdk.getLogger(...namespace);
+  }
+  getTabStorage(namespace, ...subnamespace) {
+    return this.sdk.getTabStorage(namespace, ...subnamespace);
+  }
+  getBrowserStorage(namespace, ...subnamespace) {
+    return this.sdk.getBrowserStorage(namespace, ...subnamespace);
+  }
+  close() {
+    return this.sdk.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SdkFacade
+});
+//# sourceMappingURL=sdkFacade.cjs.map

package/facade/sessionFacade.cjs

@@ -0,0 +1,36 @@
+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 sessionFacade_exports = {};
+__export(sessionFacade_exports, {
+  SessionFacade: () => SessionFacade
+});
+module.exports = __toCommonJS(sessionFacade_exports);
+var import_sessionPatch = require("./sessionPatch");
+class SessionFacade {
+  constructor(tracker) {
+    this.tracker = tracker;
+  }
+  edit() {
+    return new import_sessionPatch.SessionPatch(this.tracker);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionFacade
+});
+//# sourceMappingURL=sessionFacade.cjs.map

package/facade/sessionPatch.cjs

@@ -0,0 +1,48 @@
+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 sessionPatch_exports = {};
+__export(sessionPatch_exports, {
+  SessionPatch: () => SessionPatch
+});
+module.exports = __toCommonJS(sessionPatch_exports);
+var import_activeRecord = require("../activeRecord");
+class SessionPatch extends import_activeRecord.ActiveRecord {
+  constructor(tracker) {
+    super();
+    this.tracker = tracker;
+  }
+  save() {
+    if (!this.isDirty()) {
+      return Promise.resolve({
+        type: "sessionAttributesChanged",
+        patch: { operations: [] }
+      });
+    }
+    const promise = this.tracker.track({
+      type: "sessionAttributesChanged",
+      patch: this.buildPatch()
+    });
+    this.reset();
+    return promise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionPatch
+});
+//# sourceMappingURL=sessionPatch.cjs.map

package/facade/trackerFacade.cjs

@@ -0,0 +1,87 @@
+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 trackerFacade_exports = {};
+__export(trackerFacade_exports, {
+  TrackerFacade: () => TrackerFacade
+});
+module.exports = __toCommonJS(trackerFacade_exports);
+var import_error = require("../error");
+var import_schema = require("../schema");
+const eventSchemas = {
+  cartViewed: import_schema.cartViewed,
+  cartModified: import_schema.cartModified,
+  checkoutStarted: import_schema.checkoutStarted,
+  orderPlaced: import_schema.orderPlaced,
+  productViewed: import_schema.productViewed,
+  userSignedUp: import_schema.userSignedUp,
+  eventOccurred: import_schema.eventOccurred,
+  interestShown: import_schema.interestShown,
+  postViewed: import_schema.postViewed,
+  goalCompleted: import_schema.goalCompleted,
+  linkOpened: import_schema.linkOpened
+};
+function validateEvent(event) {
+  const { type, ...payload } = event;
+  if (!(type in eventSchemas)) {
+    throw new Error(`Unknown event type '${type}'.`);
+  }
+  try {
+    eventSchemas[type].validate(payload);
+  } catch (violation) {
+    throw new Error(`Invalid event payload: ${(0, import_error.formatCause)(violation)}`);
+  }
+}
+function createEvent(type, payload) {
+  if (typeof type !== "string") {
+    throw new Error("The event type must of type string.");
+  }
+  if (typeof payload !== "object" || payload == null) {
+    throw new Error("The event payload must of type object.");
+  }
+  const event = { type, ...payload };
+  validateEvent(event);
+  return event;
+}
+class TrackerFacade {
+  constructor(tracker) {
+    this.tracker = tracker;
+  }
+  get flushed() {
+    return this.tracker.flushed;
+  }
+  enable() {
+    this.tracker.enable();
+  }
+  disable() {
+    this.tracker.disable();
+  }
+  addListener(listener) {
+    this.tracker.addListener(listener);
+  }
+  removeListener(listener) {
+    this.tracker.removeListener(listener);
+  }
+  track(type, payload) {
+    return this.tracker.track(createEvent(type, payload));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrackerFacade
+});
+//# sourceMappingURL=trackerFacade.cjs.map