@croct/sdk 0.17.9 → 0.17.11

package/token/token.cjs

@@ -0,0 +1,239 @@
+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 token_exports = {};
+__export(token_exports, {
+  FixedTokenProvider: () => FixedTokenProvider,
+  Token: () => Token
+});
+module.exports = __toCommonJS(token_exports);
+var import_schema = require("../schema");
+var import_error = require("../error");
+var import_base64Url = require("../base64Url");
+const _Token = class _Token {
+  constructor(headers, payload, signature = "") {
+    this.headers = headers;
+    this.payload = payload;
+    this.signature = signature;
+  }
+  static issue(appId, subject = null, timestamp = Math.floor(Date.now() / 1e3)) {
+    if (timestamp < 0) {
+      throw new Error("The timestamp must be non-negative.");
+    }
+    if (subject === "") {
+      throw new Error("The subject must be non-empty.");
+    }
+    return new _Token(
+      {
+        typ: "JWT",
+        alg: "none",
+        appId
+      },
+      {
+        iss: "croct.io",
+        aud: "croct.io",
+        iat: timestamp,
+        ...subject !== null ? { sub: subject } : null
+      }
+    );
+  }
+  static parse(token) {
+    if (token === "") {
+      throw new Error("The token cannot be empty.");
+    }
+    const parts = token.split(".", 3);
+    if (parts.length < 2) {
+      throw new Error("The token is malformed.");
+    }
+    let headers;
+    let payload;
+    try {
+      headers = JSON.parse((0, import_base64Url.base64UrlDecode)(parts[0], true));
+      payload = JSON.parse((0, import_base64Url.base64UrlDecode)(parts[1], true));
+    } catch (error) {
+      throw new Error("The token is corrupted.");
+    }
+    return _Token.of(headers, payload, parts[2]);
+  }
+  static of(headers, payload, signature = "") {
+    try {
+      import_schema.tokenSchema.validate({
+        headers,
+        payload,
+        signature
+      });
+    } catch (violation) {
+      throw new Error(`The token is invalid: ${(0, import_error.formatCause)(violation)}`);
+    }
+    return new _Token(headers, payload, signature);
+  }
+  async signedWith(apiKey) {
+    const keyId = await apiKey.getIdentifierHash();
+    const headers = {
+      ...this.headers,
+      kid: keyId,
+      alg: apiKey.getSigningAlgorithm()
+    };
+    const encodedHeader = (0, import_base64Url.base64UrlEncode)(JSON.stringify(headers), true);
+    const encodedPayload = (0, import_base64Url.base64UrlEncode)(JSON.stringify(this.payload), true);
+    const signature = await apiKey.sign(`${encodedHeader}.${encodedPayload}`);
+    return new _Token(headers, this.payload, (0, import_base64Url.base64UrlEncode)(signature, false));
+  }
+  isSigned() {
+    return this.headers.alg !== "none" && this.signature !== "";
+  }
+  isSubject(subject) {
+    return this.getSubject() === subject;
+  }
+  isAnonymous() {
+    return this.payload.sub === void 0;
+  }
+  isValidNow(now = Math.floor(Date.now() / 1e3)) {
+    const { exp, iat } = this.payload;
+    return (exp === void 0 || exp >= now) && iat <= now;
+  }
+  isNewerThan(token) {
+    return this.payload.iat > token.payload.iat;
+  }
+  async matchesKeyId(apiKey) {
+    return this.headers.kid === await apiKey.getIdentifierHash();
+  }
+  getHeaders() {
+    return { ...this.headers };
+  }
+  getPayload() {
+    return { ...this.payload };
+  }
+  getSignature() {
+    return this.signature;
+  }
+  getApplicationId() {
+    return this.headers.appId ?? null;
+  }
+  getAlgorithm() {
+    return this.headers.alg;
+  }
+  getType() {
+    return this.headers.typ;
+  }
+  getKeyId() {
+    return this.headers.kid ?? null;
+  }
+  getSubject() {
+    return this.payload.sub ?? null;
+  }
+  getIssueTime() {
+    return this.payload.iat;
+  }
+  getExpirationTime() {
+    return this.payload.exp ?? null;
+  }
+  getTokenId() {
+    return this.payload.jti ?? null;
+  }
+  getAudience() {
+    return this.payload.aud;
+  }
+  getIssuer() {
+    return this.payload.iss;
+  }
+  withTokenId(tokenId) {
+    if (tokenId === "" || !_Token.UUID_PATTERN.test(tokenId)) {
+      throw new Error("The token ID must be a valid UUID.");
+    }
+    return new _Token(
+      this.headers,
+      {
+        ...this.payload,
+        jti: tokenId
+      },
+      this.signature
+    );
+  }
+  withDuration(duration, now = Math.floor(Date.now() / 1e3)) {
+    return new _Token(
+      this.headers,
+      {
+        ...this.payload,
+        iat: now,
+        exp: now + duration
+      },
+      this.signature
+    );
+  }
+  withAddedHeaders(headers) {
+    return this.withHeaders({
+      ...this.headers,
+      ...Object.fromEntries(
+        Object.entries(headers).filter(([, value]) => value !== void 0)
+      )
+    });
+  }
+  withAddedClaims(claims) {
+    return this.withPayload({
+      ...this.payload,
+      ...Object.fromEntries(
+        Object.entries(claims).filter(([, value]) => value !== void 0)
+      )
+    });
+  }
+  withHeaders(headers) {
+    return new _Token(
+      headers,
+      this.payload,
+      this.signature
+    );
+  }
+  withPayload(payload) {
+    return new _Token(
+      this.headers,
+      payload,
+      this.signature
+    );
+  }
+  withSignature(signature) {
+    return new _Token(
+      this.headers,
+      this.payload,
+      signature
+    );
+  }
+  toJSON() {
+    return this.toString();
+  }
+  toString() {
+    const headers = (0, import_base64Url.base64UrlEncode)(JSON.stringify(this.headers), true);
+    const payload = (0, import_base64Url.base64UrlEncode)(JSON.stringify(this.payload), true);
+    return `${headers}.${payload}.${this.signature}`;
+  }
+};
+_Token.UUID_PATTERN = /^[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}$/;
+let Token = _Token;
+class FixedTokenProvider {
+  constructor(token) {
+    this.token = token;
+  }
+  getToken() {
+    return this.token;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FixedTokenProvider,
+  Token
+});
+//# sourceMappingURL=token.cjs.map

package/tracker.cjs

@@ -0,0 +1,358 @@
+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 tracker_exports = {};
+__export(tracker_exports, {
+  Tracker: () => Tracker
+});
+module.exports = __toCommonJS(tracker_exports);
+var import_logging = require("./logging");
+var import_error = require("./error");
+var import_trackingEvents = require("./trackingEvents");
+const trackedEvents = {};
+class Tracker {
+  constructor(config) {
+    this.listeners = [];
+    this.pending = [];
+    this.state = {
+      enabled: false,
+      initialized: false,
+      suspended: false
+    };
+    this.inactivityTimer = {
+      since: 0
+    };
+    const { tab, tokenProvider, channel, logger, inactivityRetryPolicy, ...options } = config;
+    this.tab = tab;
+    this.tokenProvider = tokenProvider;
+    this.inactivityRetryPolicy = inactivityRetryPolicy;
+    this.channel = channel;
+    this.logger = logger ?? new import_logging.NullLogger();
+    this.processor = config.processor;
+    this.options = {
+      ...options,
+      eventMetadata: options.eventMetadata ?? {}
+    };
+    this.enable = this.enable.bind(this);
+    this.disable = this.disable.bind(this);
+    this.suspend = this.suspend.bind(this);
+    this.unsuspend = this.unsuspend.bind(this);
+    this.trackPageLoad = this.trackPageLoad.bind(this);
+    this.trackTabVisibilityChange = this.trackTabVisibilityChange.bind(this);
+    this.trackTabUrlChange = this.trackTabUrlChange.bind(this);
+    this.trackInactivity = this.trackInactivity.bind(this);
+  }
+  addListener(listener) {
+    this.listeners.push(listener);
+  }
+  removeListener(listener) {
+    let index = this.listeners.indexOf(listener);
+    while (index >= 0) {
+      this.listeners.splice(index, 1);
+      index = this.listeners.indexOf(listener);
+    }
+  }
+  get flushed() {
+    const suppress = () => {
+    };
+    return Promise.all(this.pending).then(suppress, suppress);
+  }
+  isEnabled() {
+    return this.state.enabled;
+  }
+  isSuspended() {
+    return this.state.suspended;
+  }
+  enable() {
+    if (this.state.enabled) {
+      return;
+    }
+    this.logger.info("Tracker enabled");
+    this.state.enabled = true;
+    if (this.state.suspended) {
+      return;
+    }
+    this.startInactivityTimer();
+    if (!this.state.initialized) {
+      this.state.initialized = true;
+      this.initialize();
+    }
+    this.tab.addListener("load", this.trackPageLoad);
+    this.tab.addListener("urlChange", this.trackTabUrlChange);
+    this.tab.addListener("visibilityChange", this.trackTabVisibilityChange);
+  }
+  disable() {
+    if (!this.state.enabled) {
+      return;
+    }
+    this.logger.info("Tracker disabled");
+    this.state.enabled = false;
+    if (this.state.suspended) {
+      return;
+    }
+    this.tab.removeListener("load", this.trackPageLoad);
+    this.tab.removeListener("urlChange", this.trackTabUrlChange);
+    this.tab.removeListener("visibilityChange", this.trackTabVisibilityChange);
+    this.stopInactivityTimer();
+  }
+  suspend() {
+    if (this.state.suspended) {
+      return;
+    }
+    this.logger.info("Tracker suspended");
+    if (this.state.enabled) {
+      this.disable();
+      this.state.enabled = true;
+    }
+    this.state.suspended = true;
+  }
+  unsuspend() {
+    if (!this.state.suspended) {
+      return;
+    }
+    this.logger.info("Tracker unsuspended");
+    this.state.suspended = false;
+    if (this.state.enabled) {
+      this.state.enabled = false;
+      this.enable();
+    }
+  }
+  initialize() {
+    if (trackedEvents[this.tab.id] === void 0) {
+      trackedEvents[this.tab.id] = {};
+    }
+    const initEvents = trackedEvents[this.tab.id];
+    if (this.tab.isNew && !initEvents.tabOpened) {
+      initEvents.tabOpened = true;
+      this.trackTabOpen({ tabId: this.tab.id });
+    }
+    if (!initEvents.pageOpened) {
+      initEvents.pageOpened = true;
+      this.trackPageOpen({
+        url: this.tab.url,
+        referrer: this.tab.referrer
+      });
+    }
+  }
+  stopInactivityTimer() {
+    if (this.inactivityTimer.id !== void 0) {
+      window.clearTimeout(this.inactivityTimer.id);
+      delete this.inactivityTimer.id;
+    }
+  }
+  startInactivityTimer() {
+    this.stopInactivityTimer();
+    this.inactivityTimer.since = Date.now();
+    let iteration = -1;
+    const startTimer = () => {
+      if (!this.inactivityRetryPolicy.shouldRetry(iteration + 1, this.inactivityTimer.since)) {
+        window.clearTimeout(this.inactivityTimer.id);
+        return;
+      }
+      iteration += 1;
+      this.inactivityTimer.id = window.setTimeout(
+        () => {
+          this.trackInactivity();
+          startTimer();
+        },
+        this.inactivityRetryPolicy.getDelay(iteration)
+      );
+    };
+    startTimer();
+  }
+  track(event, timestamp = Date.now()) {
+    return this.dispatch(this.enrichEvent(event, timestamp), timestamp).then(() => event);
+  }
+  trackPageOpen({ referrer, ...payload }) {
+    this.enqueue({
+      type: "pageOpened",
+      ...payload,
+      ...referrer.length > 0 ? { referrer } : {}
+    });
+  }
+  trackPageLoad({ detail: { tab } }) {
+    this.enqueue({
+      type: "pageLoaded",
+      url: tab.url,
+      title: tab.title,
+      lastModifiedTime: Date.parse(tab.document.lastModified)
+    });
+  }
+  trackTabOpen(payload) {
+    this.enqueue({
+      type: "tabOpened",
+      ...payload
+    });
+  }
+  trackTabUrlChange({ detail }) {
+    this.enqueue({
+      type: "tabUrlChanged",
+      tabId: detail.tab.id,
+      url: detail.url
+    });
+  }
+  trackTabVisibilityChange({ detail }) {
+    this.enqueue({
+      type: "tabVisibilityChanged",
+      tabId: detail.tab.id,
+      visibility: detail.visible ? "visible" : "hidden"
+    });
+  }
+  trackInactivity() {
+    this.enqueue({
+      type: "nothingChanged",
+      sinceTime: this.inactivityTimer.since
+    });
+  }
+  enqueue(event, timestamp = Date.now()) {
+    this.dispatch(event, timestamp).catch(() => {
+    });
+  }
+  notifyEvent(event) {
+    this.listeners.map((listener) => listener(event));
+  }
+  dispatch(event, timestamp) {
+    const userToken = this.tokenProvider.getToken();
+    const metadata = this.options.eventMetadata;
+    const context = {
+      tabId: this.tab.id,
+      url: this.tab.url,
+      ...Object.keys(metadata).length > 0 ? { metadata } : {}
+    };
+    const queuedEvent = {
+      ...userToken !== null ? { userToken } : {},
+      event,
+      timestamp,
+      context
+    };
+    const processedEvents = this.processor !== void 0 ? this.processor.process(queuedEvent) : [queuedEvent];
+    processedEvents.sort((left, right) => left.timestamp - right.timestamp);
+    let result = null;
+    for (const processedEvent of processedEvents) {
+      if (processedEvent === queuedEvent) {
+        result = this.publish(queuedEvent);
+        continue;
+      }
+      this.publish(processedEvent);
+    }
+    if (result === null) {
+      return Promise.reject(new Error("Event suppressed."));
+    }
+    return result;
+  }
+  publish(queuedEvent) {
+    const { event } = queuedEvent;
+    if (event.type !== "nothingChanged") {
+      this.stopInactivityTimer();
+    }
+    const eventInfo = {
+      ...queuedEvent,
+      status: "pending"
+    };
+    if (this.state.suspended) {
+      this.logger.warn(`Tracker is suspended, ignoring event "${event.type}"`);
+      this.notifyEvent({ ...eventInfo, status: "ignored" });
+      return Promise.reject(new Error("The tracker is suspended."));
+    }
+    this.logger.info(`Tracked event "${event.type}"`);
+    this.notifyEvent(eventInfo);
+    return new Promise((resolve, reject) => {
+      const promise = this.channel.publish(this.createBeacon(queuedEvent)).then(
+        () => {
+          this.logger.debug(`Successfully published event "${event.type}"`);
+          this.notifyEvent({ ...eventInfo, status: "confirmed" });
+          resolve(event);
+        },
+        (cause) => {
+          this.logger.error(`Failed to publish event "${event.type}", reason: ${(0, import_error.formatCause)(cause)}`);
+          this.notifyEvent({ ...eventInfo, status: "failed" });
+          reject(cause);
+        }
+      );
+      this.pending.push(promise);
+      promise.finally(() => {
+        this.pending.splice(this.pending.indexOf(promise), 1);
+      });
+      if (this.state.enabled && event.type !== "nothingChanged") {
+        this.startInactivityTimer();
+      }
+    });
+  }
+  enrichEvent(event, timestamp) {
+    if ((0, import_trackingEvents.isCartPartialEvent)(event)) {
+      const { cart: { lastUpdateTime = timestamp, ...cart }, ...payload } = event;
+      return {
+        ...payload,
+        cart: {
+          ...cart,
+          lastUpdateTime
+        }
+      };
+    }
+    return event;
+  }
+  createBeacon({ event, timestamp, context, userToken }) {
+    return {
+      timestamp,
+      ...userToken !== void 0 ? { token: userToken.toString() } : {},
+      context,
+      payload: this.enrichBeaconPayload(this.createBeaconPayload(event))
+    };
+  }
+  createBeaconPayload(event) {
+    if (!(0, import_trackingEvents.isIdentifiedUserEvent)(event)) {
+      return event;
+    }
+    if (event.type === "userSignedUp" && event.profile !== void 0) {
+      const { userId: userId2, profile, ...payload2 } = event;
+      return {
+        ...payload2,
+        externalUserId: userId2,
+        patch: {
+          operations: [
+            {
+              type: "merge",
+              path: ".",
+              value: profile
+            }
+          ]
+        }
+      };
+    }
+    const { userId, ...payload } = event;
+    return {
+      ...payload,
+      externalUserId: userId
+    };
+  }
+  enrichBeaconPayload(event) {
+    switch (event.type) {
+      case "linkOpened":
+        return {
+          ...event,
+          link: new URL(event.link, this.tab.url).toString()
+        };
+      default:
+        return event;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Tracker
+});
+//# sourceMappingURL=tracker.cjs.map

package/trackingEvents.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 trackingEvents_exports = {};
+__export(trackingEvents_exports, {
+  cartEventTypes: () => cartEventTypes,
+  ecommerceEventTypes: () => ecommerceEventTypes,
+  eventTypes: () => eventTypes,
+  identifiedUserEventTypes: () => identifiedUserEventTypes,
+  isCartPartialEvent: () => isCartPartialEvent,
+  isIdentifiedUserEvent: () => isIdentifiedUserEvent,
+  miscEventTypes: () => miscEventTypes,
+  pageEventTypes: () => pageEventTypes,
+  tabEventTypes: () => tabEventTypes,
+  userEventTypes: () => userEventTypes
+});
+module.exports = __toCommonJS(trackingEvents_exports);
+const pageEventTypes = [
+  "pageLoaded",
+  "pageOpened"
+];
+const tabEventTypes = [
+  "tabOpened",
+  "tabUrlChanged",
+  "tabVisibilityChanged"
+];
+const cartEventTypes = [
+  "cartModified",
+  "cartViewed",
+  "checkoutStarted"
+];
+const ecommerceEventTypes = [
+  ...cartEventTypes,
+  "orderPlaced",
+  "productViewed"
+];
+const identifiedUserEventTypes = [
+  "userSignedIn",
+  "userSignedOut",
+  "userSignedUp"
+];
+const userEventTypes = [
+  ...identifiedUserEventTypes,
+  "userProfileChanged"
+];
+const miscEventTypes = [
+  "nothingChanged",
+  "sessionAttributesChanged",
+  "goalCompleted",
+  "interestShown",
+  "postViewed",
+  "eventOccurred",
+  "linkOpened"
+];
+const eventTypes = [
+  ...pageEventTypes,
+  ...ecommerceEventTypes,
+  ...userEventTypes,
+  ...miscEventTypes
+];
+function isIdentifiedUserEvent(event) {
+  return identifiedUserEventTypes.includes(event.type);
+}
+function isCartPartialEvent(event) {
+  return cartEventTypes.includes(event.type);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cartEventTypes,
+  ecommerceEventTypes,
+  eventTypes,
+  identifiedUserEventTypes,
+  isCartPartialEvent,
+  isIdentifiedUserEvent,
+  miscEventTypes,
+  pageEventTypes,
+  tabEventTypes,
+  userEventTypes
+});
+//# sourceMappingURL=trackingEvents.cjs.map

package/transformer.cjs

@@ -0,0 +1,30 @@
+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 transformer_exports = {};
+__export(transformer_exports, {
+  encodeJson: () => encodeJson
+});
+module.exports = __toCommonJS(transformer_exports);
+const encodeJson = function encodeJson2(input) {
+  return Promise.resolve(JSON.stringify(input));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  encodeJson
+});
+//# sourceMappingURL=transformer.cjs.map