@frontegg/redux-store 7.0.0-alpha.1 → 7.0.0-alpha.10

package/helpers/sha256.js

@@ -0,0 +1,424 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ *
+ * THIS IS CUSTOM VERSION OF JS-SHA256 that will be used only
+ * on non-secure domain due to the native `crypto.subtle.digest`
+ * isn't accessible from non-secure domains.
+ *
+ * NOTE: Changes from 0.9.0:
+ * - Remove any usage of eval scripts
+ * - Remove support for UMD and AMD exports
+ * - Remove support for CommonJS
+ * - Make it typescript
+ *
+ * [js-sha256]{@link https://github.com/emn178/js-sha256}
+ *
+ * @version 0.9.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2017
+ * @license MIT
+ */
+
+const ERROR = 'input is invalid type';
+const ARRAY_BUFFER = typeof ArrayBuffer !== 'undefined';
+const HEX_CHARS = '0123456789abcdef'.split('');
+const EXTRA = [-2147483648, 8388608, 32768, 128];
+const SHIFT = [24, 16, 8, 0];
+const K = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2];
+const OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];
+const blocks = [];
+if (!Array.isArray) {
+  Array.isArray = function (arg) {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+  };
+}
+if (ARRAY_BUFFER && !ArrayBuffer.isView) {
+  ArrayBuffer.isView = function (arg) {
+    return typeof arg === 'object' && arg.buffer && arg.buffer.constructor === ArrayBuffer;
+  };
+}
+const createOutputMethod = function (outputType) {
+  return function (message) {
+    const instance = new Sha256(true);
+    const sha256MessageInstance = instance.update(message);
+    return sha256MessageInstance == null ? void 0 : sha256MessageInstance[outputType]();
+  };
+};
+const createMethod = function () {
+  const method = createOutputMethod('hex');
+  method.create = function () {
+    return new Sha256();
+  };
+  method.update = function (message) {
+    return method.create().update(message);
+  };
+  for (let i = 0; i < OUTPUT_TYPES.length; ++i) {
+    const type = OUTPUT_TYPES[i];
+    method[type] = createOutputMethod(type);
+  }
+  return method;
+};
+const createHmacOutputMethod = function (outputType) {
+  return function (key, message) {
+    const instance = new HmacSha256(key, true);
+    const hmacMessageInstance = instance.update(message);
+    return hmacMessageInstance == null ? void 0 : hmacMessageInstance[outputType]();
+  };
+};
+const createHmacMethod = function () {
+  const method = createHmacOutputMethod('hex');
+  method.create = function (key) {
+    return new HmacSha256(key);
+  };
+  method.update = function (key, message) {
+    return method.create(key).update(message);
+  };
+  for (let i = 0; i < OUTPUT_TYPES.length; ++i) {
+    const type = OUTPUT_TYPES[i];
+    method[type] = createHmacOutputMethod(type);
+  }
+  return method;
+};
+class Sha256 {
+  constructor(sharedMemory = false) {
+    this.blocks = void 0;
+    this.h0 = void 0;
+    this.h1 = void 0;
+    this.h2 = void 0;
+    this.h3 = void 0;
+    this.h4 = void 0;
+    this.h5 = void 0;
+    this.h6 = void 0;
+    this.h7 = void 0;
+    this.block = void 0;
+    this.start = void 0;
+    this.bytes = void 0;
+    this.hBytes = void 0;
+    this.finalized = void 0;
+    this.hashed = void 0;
+    this.first = void 0;
+    this.lastByteIndex = void 0;
+    this.sharedMemory = false;
+    this.toString = () => this.hex();
+    this.array = () => Sha256.prototype.digest();
+    if (sharedMemory) {
+      blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+      this.blocks = blocks;
+    } else {
+      this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    }
+    this.h0 = 0x6a09e667;
+    this.h1 = 0xbb67ae85;
+    this.h2 = 0x3c6ef372;
+    this.h3 = 0xa54ff53a;
+    this.h4 = 0x510e527f;
+    this.h5 = 0x9b05688c;
+    this.h6 = 0x1f83d9ab;
+    this.h7 = 0x5be0cd19;
+    this.block = this.start = this.bytes = this.hBytes = 0;
+    this.finalized = this.hashed = false;
+    this.first = true;
+    this.sharedMemory = sharedMemory;
+  }
+  update(message) {
+    if (this.finalized) {
+      return undefined;
+    }
+    let notString;
+    const type = typeof message;
+    if (type !== 'string') {
+      if (type === 'object') {
+        if (message === null) {
+          throw new Error(ERROR);
+        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
+          message = new Uint8Array(message);
+        } else if (!Array.isArray(message)) {
+          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
+            throw new Error(ERROR);
+          }
+        }
+      } else {
+        throw new Error(ERROR);
+      }
+      notString = true;
+    }
+    let code,
+      index = 0,
+      i;
+    const length = message.length;
+    const blocks = this.blocks;
+    while (index < length) {
+      if (this.hashed) {
+        this.hashed = false;
+        blocks[0] = this.block;
+        blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+      }
+      if (notString) {
+        for (i = this.start; index < length && i < 64; ++index) {
+          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
+        }
+      } else {
+        for (i = this.start; index < length && i < 64; ++index) {
+          code = message.charCodeAt(index);
+          if (code < 0x80) {
+            blocks[i >> 2] |= code << SHIFT[i++ & 3];
+          } else if (code < 0x800) {
+            blocks[i >> 2] |= (0xc0 | code >> 6) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | code & 0x3f) << SHIFT[i++ & 3];
+          } else if (code < 0xd800 || code >= 0xe000) {
+            blocks[i >> 2] |= (0xe0 | code >> 12) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | code >> 6 & 0x3f) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | code & 0x3f) << SHIFT[i++ & 3];
+          } else {
+            code = 0x10000 + ((code & 0x3ff) << 10 | message.charCodeAt(++index) & 0x3ff);
+            blocks[i >> 2] |= (0xf0 | code >> 18) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | code >> 12 & 0x3f) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | code >> 6 & 0x3f) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | code & 0x3f) << SHIFT[i++ & 3];
+          }
+        }
+      }
+      this.lastByteIndex = i;
+      this.bytes += i - this.start;
+      if (i >= 64) {
+        this.block = blocks[16];
+        this.start = i - 64;
+        this.hash();
+        this.hashed = true;
+      } else {
+        this.start = i;
+      }
+    }
+    if (this.bytes > 4294967295) {
+      this.hBytes += this.bytes / 4294967296 << 0;
+      this.bytes = this.bytes % 4294967296;
+    }
+    return this;
+  }
+  finalize() {
+    if (this.finalized) {
+      return;
+    }
+    this.finalized = true;
+    const blocks = this.blocks,
+      i = this.lastByteIndex;
+    blocks[16] = this.block;
+    blocks[i >> 2] |= EXTRA[i & 3];
+    this.block = blocks[16];
+    if (i >= 56) {
+      if (!this.hashed) {
+        this.hash();
+      }
+      blocks[0] = this.block;
+      blocks[16] = blocks[1] = blocks[2] = blocks[3] = blocks[4] = blocks[5] = blocks[6] = blocks[7] = blocks[8] = blocks[9] = blocks[10] = blocks[11] = blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+    }
+    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
+    blocks[15] = this.bytes << 3;
+    this.hash();
+  }
+  hash() {
+    let a = this.h0,
+      b = this.h1,
+      c = this.h2,
+      d = this.h3,
+      e = this.h4,
+      f = this.h5,
+      g = this.h6,
+      h = this.h7,
+      j,
+      s0,
+      s1,
+      maj,
+      t1,
+      t2,
+      ch,
+      ab,
+      da,
+      cd,
+      bc;
+    const blocks = this.blocks;
+    for (j = 16; j < 64; ++j) {
+      // rightrotate
+      t1 = blocks[j - 15];
+      s0 = (t1 >>> 7 | t1 << 25) ^ (t1 >>> 18 | t1 << 14) ^ t1 >>> 3;
+      t1 = blocks[j - 2];
+      s1 = (t1 >>> 17 | t1 << 15) ^ (t1 >>> 19 | t1 << 13) ^ t1 >>> 10;
+      blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 << 0;
+    }
+    bc = b & c;
+    for (j = 0; j < 64; j += 4) {
+      if (this.first) {
+        ab = 704751109;
+        t1 = blocks[0] - 210244248;
+        h = t1 - 1521486534 << 0;
+        d = t1 + 143694565 << 0;
+        this.first = false;
+      } else {
+        s0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+        s1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+        ab = a & b;
+        maj = ab ^ a & c ^ bc;
+        ch = e & f ^ ~e & g;
+        t1 = h + s1 + ch + K[j] + blocks[j];
+        t2 = s0 + maj;
+        h = d + t1 << 0;
+        d = t1 + t2 << 0;
+      }
+      s0 = (d >>> 2 | d << 30) ^ (d >>> 13 | d << 19) ^ (d >>> 22 | d << 10);
+      s1 = (h >>> 6 | h << 26) ^ (h >>> 11 | h << 21) ^ (h >>> 25 | h << 7);
+      da = d & a;
+      maj = da ^ d & b ^ ab;
+      ch = h & e ^ ~h & f;
+      t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];
+      t2 = s0 + maj;
+      g = c + t1 << 0;
+      c = t1 + t2 << 0;
+      s0 = (c >>> 2 | c << 30) ^ (c >>> 13 | c << 19) ^ (c >>> 22 | c << 10);
+      s1 = (g >>> 6 | g << 26) ^ (g >>> 11 | g << 21) ^ (g >>> 25 | g << 7);
+      cd = c & d;
+      maj = cd ^ c & a ^ da;
+      ch = g & h ^ ~g & e;
+      t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];
+      t2 = s0 + maj;
+      f = b + t1 << 0;
+      b = t1 + t2 << 0;
+      s0 = (b >>> 2 | b << 30) ^ (b >>> 13 | b << 19) ^ (b >>> 22 | b << 10);
+      s1 = (f >>> 6 | f << 26) ^ (f >>> 11 | f << 21) ^ (f >>> 25 | f << 7);
+      bc = b & c;
+      maj = bc ^ b & d ^ cd;
+      ch = f & g ^ ~f & h;
+      t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];
+      t2 = s0 + maj;
+      e = a + t1 << 0;
+      a = t1 + t2 << 0;
+    }
+    this.h0 = this.h0 + a << 0;
+    this.h1 = this.h1 + b << 0;
+    this.h2 = this.h2 + c << 0;
+    this.h3 = this.h3 + d << 0;
+    this.h4 = this.h4 + e << 0;
+    this.h5 = this.h5 + f << 0;
+    this.h6 = this.h6 + g << 0;
+    this.h7 = this.h7 + h << 0;
+  }
+  hex() {
+    this.finalize();
+    const h0 = this.h0,
+      h1 = this.h1,
+      h2 = this.h2,
+      h3 = this.h3,
+      h4 = this.h4,
+      h5 = this.h5,
+      h6 = this.h6,
+      h7 = this.h7;
+    let hex = HEX_CHARS[h0 >> 28 & 0x0f] + HEX_CHARS[h0 >> 24 & 0x0f] + HEX_CHARS[h0 >> 20 & 0x0f] + HEX_CHARS[h0 >> 16 & 0x0f] + HEX_CHARS[h0 >> 12 & 0x0f] + HEX_CHARS[h0 >> 8 & 0x0f] + HEX_CHARS[h0 >> 4 & 0x0f] + HEX_CHARS[h0 & 0x0f] + HEX_CHARS[h1 >> 28 & 0x0f] + HEX_CHARS[h1 >> 24 & 0x0f] + HEX_CHARS[h1 >> 20 & 0x0f] + HEX_CHARS[h1 >> 16 & 0x0f] + HEX_CHARS[h1 >> 12 & 0x0f] + HEX_CHARS[h1 >> 8 & 0x0f] + HEX_CHARS[h1 >> 4 & 0x0f] + HEX_CHARS[h1 & 0x0f] + HEX_CHARS[h2 >> 28 & 0x0f] + HEX_CHARS[h2 >> 24 & 0x0f] + HEX_CHARS[h2 >> 20 & 0x0f] + HEX_CHARS[h2 >> 16 & 0x0f] + HEX_CHARS[h2 >> 12 & 0x0f] + HEX_CHARS[h2 >> 8 & 0x0f] + HEX_CHARS[h2 >> 4 & 0x0f] + HEX_CHARS[h2 & 0x0f] + HEX_CHARS[h3 >> 28 & 0x0f] + HEX_CHARS[h3 >> 24 & 0x0f] + HEX_CHARS[h3 >> 20 & 0x0f] + HEX_CHARS[h3 >> 16 & 0x0f] + HEX_CHARS[h3 >> 12 & 0x0f] + HEX_CHARS[h3 >> 8 & 0x0f] + HEX_CHARS[h3 >> 4 & 0x0f] + HEX_CHARS[h3 & 0x0f] + HEX_CHARS[h4 >> 28 & 0x0f] + HEX_CHARS[h4 >> 24 & 0x0f] + HEX_CHARS[h4 >> 20 & 0x0f] + HEX_CHARS[h4 >> 16 & 0x0f] + HEX_CHARS[h4 >> 12 & 0x0f] + HEX_CHARS[h4 >> 8 & 0x0f] + HEX_CHARS[h4 >> 4 & 0x0f] + HEX_CHARS[h4 & 0x0f] + HEX_CHARS[h5 >> 28 & 0x0f] + HEX_CHARS[h5 >> 24 & 0x0f] + HEX_CHARS[h5 >> 20 & 0x0f] + HEX_CHARS[h5 >> 16 & 0x0f] + HEX_CHARS[h5 >> 12 & 0x0f] + HEX_CHARS[h5 >> 8 & 0x0f] + HEX_CHARS[h5 >> 4 & 0x0f] + HEX_CHARS[h5 & 0x0f] + HEX_CHARS[h6 >> 28 & 0x0f] + HEX_CHARS[h6 >> 24 & 0x0f] + HEX_CHARS[h6 >> 20 & 0x0f] + HEX_CHARS[h6 >> 16 & 0x0f] + HEX_CHARS[h6 >> 12 & 0x0f] + HEX_CHARS[h6 >> 8 & 0x0f] + HEX_CHARS[h6 >> 4 & 0x0f] + HEX_CHARS[h6 & 0x0f];
+    hex += HEX_CHARS[h7 >> 28 & 0x0f] + HEX_CHARS[h7 >> 24 & 0x0f] + HEX_CHARS[h7 >> 20 & 0x0f] + HEX_CHARS[h7 >> 16 & 0x0f] + HEX_CHARS[h7 >> 12 & 0x0f] + HEX_CHARS[h7 >> 8 & 0x0f] + HEX_CHARS[h7 >> 4 & 0x0f] + HEX_CHARS[h7 & 0x0f];
+    return hex;
+  }
+  digest() {
+    this.finalize();
+    const h0 = this.h0,
+      h1 = this.h1,
+      h2 = this.h2,
+      h3 = this.h3,
+      h4 = this.h4,
+      h5 = this.h5,
+      h6 = this.h6,
+      h7 = this.h7;
+    const arr = [h0 >> 24 & 0xff, h0 >> 16 & 0xff, h0 >> 8 & 0xff, h0 & 0xff, h1 >> 24 & 0xff, h1 >> 16 & 0xff, h1 >> 8 & 0xff, h1 & 0xff, h2 >> 24 & 0xff, h2 >> 16 & 0xff, h2 >> 8 & 0xff, h2 & 0xff, h3 >> 24 & 0xff, h3 >> 16 & 0xff, h3 >> 8 & 0xff, h3 & 0xff, h4 >> 24 & 0xff, h4 >> 16 & 0xff, h4 >> 8 & 0xff, h4 & 0xff, h5 >> 24 & 0xff, h5 >> 16 & 0xff, h5 >> 8 & 0xff, h5 & 0xff, h6 >> 24 & 0xff, h6 >> 16 & 0xff, h6 >> 8 & 0xff, h6 & 0xff];
+    arr.push(h7 >> 24 & 0xff, h7 >> 16 & 0xff, h7 >> 8 & 0xff, h7 & 0xff);
+    return arr;
+  }
+  arrayBuffer() {
+    this.finalize();
+    const buffer = new ArrayBuffer(32);
+    const dataView = new DataView(buffer);
+    dataView.setUint32(0, this.h0);
+    dataView.setUint32(4, this.h1);
+    dataView.setUint32(8, this.h2);
+    dataView.setUint32(12, this.h3);
+    dataView.setUint32(16, this.h4);
+    dataView.setUint32(20, this.h5);
+    dataView.setUint32(24, this.h6);
+    dataView.setUint32(28, this.h7);
+    return buffer;
+  }
+}
+class HmacSha256 extends Sha256 {
+  constructor(key, sharedMemory = false) {
+    super(sharedMemory);
+    this.inner = void 0;
+    this.oKeyPad = void 0;
+    let i;
+    const type = typeof key;
+    if (type === 'string') {
+      const bytes = [],
+        length = key.length;
+      let index = 0,
+        code;
+      for (i = 0; i < length; ++i) {
+        code = key.charCodeAt(i);
+        if (code < 0x80) {
+          bytes[index++] = code;
+        } else if (code < 0x800) {
+          bytes[index++] = 0xc0 | code >> 6;
+          bytes[index++] = 0x80 | code & 0x3f;
+        } else if (code < 0xd800 || code >= 0xe000) {
+          bytes[index++] = 0xe0 | code >> 12;
+          bytes[index++] = 0x80 | code >> 6 & 0x3f;
+          bytes[index++] = 0x80 | code & 0x3f;
+        } else {
+          code = 0x10000 + ((code & 0x3ff) << 10 | key.charCodeAt(++i) & 0x3ff);
+          bytes[index++] = 0xf0 | code >> 18;
+          bytes[index++] = 0x80 | code >> 12 & 0x3f;
+          bytes[index++] = 0x80 | code >> 6 & 0x3f;
+          bytes[index++] = 0x80 | code & 0x3f;
+        }
+      }
+      key = bytes;
+    } else {
+      if (type === 'object') {
+        if (key === null) {
+          throw new Error(ERROR);
+        } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {
+          key = new Uint8Array(key);
+        } else if (!Array.isArray(key)) {
+          if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {
+            throw new Error(ERROR);
+          }
+        }
+      } else {
+        throw new Error(ERROR);
+      }
+    }
+    if (key.length > 64) {
+      var _Sha256$update;
+      key = (_Sha256$update = new Sha256(true).update(key)) == null ? void 0 : _Sha256$update.array();
+    }
+    const oKeyPad = [],
+      iKeyPad = [];
+    for (i = 0; i < 64; ++i) {
+      const b = key[i] || 0;
+      oKeyPad[i] = 0x5c ^ b;
+      iKeyPad[i] = 0x36 ^ b;
+    }
+    Sha256.call(this, sharedMemory);
+    this.update(iKeyPad);
+    this.oKeyPad = oKeyPad;
+    this.inner = true;
+    this.sharedMemory = sharedMemory;
+  }
+  finalize() {
+    super.finalize();
+    if (this.inner) {
+      this.inner = false;
+      const innerHash = this.array();
+      Sha256.call(this, this.sharedMemory);
+      this.update(this.oKeyPad);
+      this.update(innerHash);
+      Sha256.prototype.finalize.call(this);
+    }
+  }
+}
+export const sha256 = createMethod();
+export const hmac = createHmacMethod();

package/index.d.ts

@@ -1,17 +1,16 @@
-export { default as auth } from './auth';
-export { default as audits } from './audits';
-export { default as connectivity } from './connectivity';
-export { default as subscriptions } from './subscriptions';
-export { default as vendor } from './vendor';
+export * from './toolkit';
+export * from './constants';
+export * from './helpers';
+export * from './auth/helpers';
+export * from './interfaces';
 export * from './auth';
-export * from './audits';
-export * from './audits/backward-compatibility';
+export * from './auth/interfaces';
 export * from './connectivity';
+export * from './connectivity/interfaces';
 export * from './subscriptions';
+export * from './subscriptions/interfaces';
 export * from './vendor';
-export * from './toolkit';
-export * from './helpers';
-export * from './utils';
-export type { WithCallback, WithSilentLoad, CallbackMethod } from './interfaces';
+export * from './vendor/interfaces';
+export * from './audits';
+export * from './audits/interfaces';
 export type { NotEntitledJustification } from '@frontegg/rest-api';
-export type { FronteggState } from './fronteggState';

package/index.js

@@ -1,19 +1,21 @@
-/** @license Frontegg v7.0.0-alpha.1
+/** @license Frontegg v7.0.0-alpha.10
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-export { default as auth } from './auth';
-export { default as audits } from './audits';
-export { default as connectivity } from './connectivity';
-export { default as subscriptions } from './subscriptions';
-export { default as vendor } from './vendor';
+export * from './toolkit';
+export * from './constants';
+export * from './helpers';
+export * from './auth/helpers';
+export * from './interfaces';
 export * from './auth';
-export * from './audits';
-export * from './audits/backward-compatibility';
+export * from './auth/interfaces';
 export * from './connectivity';
+export * from './connectivity/interfaces';
 export * from './subscriptions';
+export * from './subscriptions/interfaces';
 export * from './vendor';
-export * from './toolkit';
-export * from './helpers';
-export * from './utils';
+export * from './vendor/interfaces';
+export * from './audits';
+export * from './audits/interfaces';
+export {};

package/interfaces.d.ts

@@ -1,5 +1,77 @@
-export declare type CallbackMethod<R = boolean> = (data: R | null, error?: string) => void;
-export declare type WithCallback<T = {}, R = boolean> = T & {
+import { api, ContextOptions, fetch } from '@frontegg/rest-api';
+import { AuthActions, AuthStateActions } from './auth';
+import type { AuthState } from './auth/interfaces';
+import type { ConnectivityActions } from './connectivity';
+import type { ConnectivityState } from './connectivity/interfaces';
+import { SubscriptionsActions, SubscriptionsStateActions } from './subscriptions';
+import type { SubscriptionsState } from './subscriptions/interfaces';
+import type { VendorActions } from './vendor';
+import type { VendorState } from './vendor/interfaces';
+import { AuditsState } from './audits/interfaces';
+import { AuditsActions } from './audits';
+import { OldAuditsState } from './audits-backward-compatibility/interfaces';
+import { OldAuditsActions } from './audits-backward-compatibility';
+/**
+ * @deprecated use FronteggStore instead
+ */
+export declare type EnhancedStore = FronteggStore;
+/**
+ * @deprecated use direct actions instead
+ */
+export declare type Dispatch = (action: {
+    type: string;
+    payload?: any;
+}) => void;
+export interface FronteggStore {
+    dispatch: Dispatch;
+    getState: () => FronteggState;
+    subscribe: (callback: () => void) => () => void;
+    store: FronteggState;
+    actions: FronteggActions;
+    stateActions: FronteggStateActions;
+}
+export interface RootState {
+    appName: string;
+    context: ContextOptions;
+    urlStrategy?: 'hash' | 'path';
+    previewMode?: boolean;
+}
+export declare type FronteggState = {
+    root: RootState;
+    auth: AuthState;
+    connectivity: ConnectivityState;
+    subscriptions: SubscriptionsState;
+    vendor: VendorState;
+    auditLogs: AuditsState;
+    /** @deprecated use auditLogs instead of audits */
+    audits: OldAuditsState;
+};
+export declare type PartialFronteggState = Partial<{
+    root: DeepPartial<RootState>;
+    auth: DeepPartial<AuthState>;
+    connectivity: Partial<ConnectivityState>;
+    subscriptions: DeepPartial<SubscriptionsState>;
+    vendor: DeepPartial<VendorState>;
+    auditLogs: DeepPartial<AuditsState>;
+    /** @deprecated use auditLogs instead of audits */
+    audits: Partial<OldAuditsState>;
+}>;
+export declare type FronteggActions = AuthActions & ConnectivityActions & SubscriptionsActions & VendorActions & AuditsActions;
+export declare type FronteggStateActions = {
+    auth: AuthStateActions;
+    connectivity: ConnectivityActions;
+    subscriptions: SubscriptionsStateActions;
+    vendor: VendorActions;
+    auditLogs: AuditsActions;
+    /** @deprecated use auditLogs instead of audits */
+    audits: OldAuditsActions;
+};
+export declare type SharedActions = any;
+export declare type RestApi = typeof api & {
+    fetch: typeof fetch;
+};
+export declare type CallbackMethod<R = boolean> = (data: R | null, error?: string | any | unknown) => void;
+export declare type WithCallback<T = object, R = boolean> = T & {
     callback?: CallbackMethod<R>;
 };
 export declare type WithStatus = {
@@ -7,16 +79,18 @@ export declare type WithStatus = {
     error?: any;
     saving?: boolean;
 };
-export declare type WithId<T = {}> = T & {
+export declare type WithId<T = object> = T & {
     id: string;
 };
+export declare type WithSilentLoad<T = {}> = T & {
+    silentLoading?: boolean;
+};
 export declare type LoaderIndicatorState<T extends string> = Partial<{
     [key in T]: string | boolean;
 }>;
 export declare type ErrorsIndicatorState<T extends string> = Partial<{
     [key in T]: string | boolean;
 }>;
-export declare type WithSilentLoad<T> = T & {
-    silentLoading?: boolean;
+export declare type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends any[] | undefined ? T[P] : T[P] extends Function ? T[P] : T[P] extends object | undefined ? Partial<T[P]> : T[P];
 };
-export declare type ActionDispatchMatcher<Reducers, Actions, DispatchedActions> = Omit<Reducers & Actions, keyof DispatchedActions> & Omit<DispatchedActions, keyof (Actions & Reducers)>;

package/mocks/audits-mocks/auditLogsActions.mocks.d.ts

@@ -0,0 +1,13 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setAuditLogsState: (state: Partial<import("../../audits/AuditLogsState/interfaces").AuditLogsState>) => void;
+    resetAuditLogsState: () => void;
+    exportAuditsCsv: () => Promise<void>;
+    loadAuditLogs: (payload: import("../../interfaces").WithSilentLoad<import("../../interfaces").WithCallback<{
+        pageOffset: number;
+        pageSize?: number | undefined;
+        filter?: import("@frontegg/rest-api").QueryFilter[] | undefined;
+        sort?: import("@frontegg/rest-api").QuerySort[] | undefined;
+    }, boolean>>) => Promise<void>;
+};
+export default _default;

package/mocks/audits-mocks/auditLogsActions.mocks.js

@@ -0,0 +1,52 @@
+import { mockActionsExpect } from '../helpers';
+import { buildAuditLogsActions } from '../../audits/AuditLogsState';
+import { errorHandler } from '../../helpers';
+import { auditsLogsFilterAndSort } from './dummy';
+export default ((store, api, actions) => {
+  const originalActions = buildAuditLogsActions(store, api, actions);
+  const mockedActions = mockActionsExpect(originalActions, ['setAuditLogsState', 'resetAuditLogsState']);
+  mockedActions.loadAuditLogs = async payload => {
+    mockedActions.setAuditLogsState({
+      loading: !payload.silentLoading,
+      error: null
+    });
+    const state = store.auditLogs.auditLogsState;
+    const {
+      columns
+    } = store.auditLogs.auditsMetadataState;
+    try {
+      var _payload$pageSize, _payload$pageOffset, _payload$filter, _payload$sort, _payload$callback;
+      const pageSize = (_payload$pageSize = payload.pageSize) != null ? _payload$pageSize : state.pageSize;
+      const pageOffset = (_payload$pageOffset = payload.pageOffset) != null ? _payload$pageOffset : state.pageOffset;
+      const filter = (_payload$filter = payload.filter) != null ? _payload$filter : state.filter;
+      const sort = (_payload$sort = payload.sort) != null ? _payload$sort : state.sort;
+      mockedActions.setAuditLogsState({
+        pageSize,
+        pageOffset,
+        filter,
+        sort
+      });
+      if (!columns) {
+        await actions.loadAuditsMetadata();
+      }
+      const {
+        data,
+        total
+      } = auditsLogsFilterAndSort(filter, sort);
+      mockedActions.setAuditLogsState({
+        loading: false,
+        logs: data != null ? data : [],
+        totalPages: +Math.ceil(total / pageSize)
+      });
+      payload == null ? void 0 : (_payload$callback = payload.callback) == null ? void 0 : _payload$callback.call(payload, true);
+    } catch (e) {
+      var _payload$callback2;
+      mockedActions.setAuditLogsState({
+        loading: false,
+        error: errorHandler(e)
+      });
+      payload == null ? void 0 : (_payload$callback2 = payload.callback) == null ? void 0 : _payload$callback2.call(payload, null, e);
+    }
+  };
+  return mockedActions;
+});

package/mocks/audits-mocks/auditsMetadataActions.mocks.d.ts

@@ -0,0 +1,7 @@
+import { FronteggState, RestApi, SharedActions } from '../../interfaces';
+declare const _default: (store: FronteggState, api: RestApi, actions: SharedActions) => {
+    setAuditsMetadataState: (state: Partial<import("../..").AuditsMetadataState>) => void;
+    resetAuditsMetadataState: () => void;
+    loadAuditsMetadata: () => Promise<void>;
+};
+export default _default;