@auxilium/datalynk-client 1.0.20 → 1.1.0-rc1

package/dist/index.mjs

@@ -15,6 +15,31 @@ function clean(obj, undefinedOnly = false) {
   }
   return obj;
 }
+function deepCopy(value) {
+  try {
+    return structuredClone(value);
+  } catch {
+    return JSON.parse(JSONSanitize(value));
+  }
+}
+function dotNotation(obj, prop, set) {
+  if (obj == null || !prop) return void 0;
+  return prop.split(/[.[\]]/g).filter((prop2) => prop2.length).reduce((obj2, prop2, i, arr) => {
+    if (prop2[0] == '"' || prop2[0] == "'") prop2 = prop2.slice(1, -1);
+    if (!(obj2 == null ? void 0 : obj2.hasOwnProperty(prop2))) {
+      return void 0;
+    }
+    return obj2[prop2];
+  }, obj);
+}
+function isEqual(a, b) {
+  const ta = typeof a, tb = typeof b;
+  if (ta != "object" || a == null || (tb != "object" || b == null))
+    return ta == "function" && tb == "function" ? a.toString() == b.toString() : a === b;
+  const keys = Object.keys(a);
+  if (keys.length != Object.keys(b).length) return false;
+  return Object.keys(a).every((key) => isEqual(a[key], b[key]));
+}
 function JSONAttemptParse(json) {
   try {
     return JSON.parse(json);
@@ -32,9 +57,214 @@ function JSONSanitize(obj, space) {
     return value;
   }, space);
 }
+class ASet extends Array {
+  /** Number of elements in set */
+  get size() {
+    return this.length;
+  }
+  /**
+   * Array to create set from, duplicate values will be removed
+   * @param {T[]} elements Elements which will be added to set
+   */
+  constructor(elements = []) {
+    super();
+    if (!!(elements == null ? void 0 : elements["forEach"]))
+      elements.forEach((el) => this.add(el));
+  }
+  /**
+   * Add elements to set if unique
+   * @param items
+   */
+  add(...items) {
+    items.filter((el) => !this.has(el)).forEach((el) => this.push(el));
+    return this;
+  }
+  /**
+   * Remove all elements
+   */
+  clear() {
+    this.splice(0, this.length);
+    return this;
+  }
+  /**
+   * Delete elements from set
+   * @param items Elements that will be deleted
+   */
+  delete(...items) {
+    items.forEach((el) => {
+      const index = this.indexOf(el);
+      if (index != -1) this.splice(index, 1);
+    });
+    return this;
+  }
+  /**
+   * Create list of elements this set has which the comparison set does not
+   * @param {ASet<T>} set Set to compare against
+   * @return {ASet<T>} Different elements
+   */
+  difference(set) {
+    return new ASet(this.filter((el) => !set.has(el)));
+  }
+  /**
+   * Check if set includes element
+   * @param {T} el Element to look for
+   * @return {boolean} True if element was found, false otherwise
+   */
+  has(el) {
+    return this.indexOf(el) != -1;
+  }
+  /**
+   * Find index number of element, or -1 if it doesn't exist. Matches by equality not reference
+   *
+   * @param {T} search Element to find
+   * @param {number} fromIndex Starting index position
+   * @return {number} Element index number or -1 if missing
+   */
+  indexOf(search2, fromIndex) {
+    return super.findIndex((el) => isEqual(el, search2), fromIndex);
+  }
+  /**
+   * Create list of elements this set has in common with the comparison set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} Set of common elements
+   */
+  intersection(set) {
+    return new ASet(this.filter((el) => set.has(el)));
+  }
+  /**
+   * Check if this set has no elements in common with the comparison set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} True if nothing in common, false otherwise
+   */
+  isDisjointFrom(set) {
+    return this.intersection(set).size == 0;
+  }
+  /**
+   * Check if all elements in this set are included in the comparison set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} True if all elements are included, false otherwise
+   */
+  isSubsetOf(set) {
+    return this.findIndex((el) => !set.has(el)) == -1;
+  }
+  /**
+   * Check if all elements from comparison set are included in this set
+   * @param {ASet<T>} set Set to compare against
+   * @return {boolean} True if all elements are included, false otherwise
+   */
+  isSuperset(set) {
+    return set.findIndex((el) => !this.has(el)) == -1;
+  }
+  /**
+   * Create list of elements that are only in one set but not both (XOR)
+   * @param {ASet<T>} set Set to compare against
+   * @return {ASet<T>} New set of unique elements
+   */
+  symmetricDifference(set) {
+    return new ASet([...this.difference(set), ...set.difference(this)]);
+  }
+  /**
+   * Create joined list of elements included in this & the comparison set
+   * @param {ASet<T>} set Set join
+   * @return {ASet<T>} New set of both previous sets combined
+   */
+  union(set) {
+    return new ASet([...this, ...set]);
+  }
+}
+function sortByProp(prop, reverse = false) {
+  return function(a, b) {
+    const aVal = dotNotation(a, prop);
+    const bVal = dotNotation(b, prop);
+    if (typeof aVal == "number" && typeof bVal == "number")
+      return (reverse ? -1 : 1) * (aVal - bVal);
+    if (aVal > bVal) return reverse ? -1 : 1;
+    if (aVal < bVal) return reverse ? 1 : -1;
+    return 0;
+  };
+}
 function makeArray(value) {
   return Array.isArray(value) ? value : [value];
 }
+class Database {
+  constructor(database, tables, version2) {
+    __publicField2(this, "connection");
+    __publicField2(this, "tables");
+    this.database = database;
+    this.version = version2;
+    this.connection = new Promise((resolve, reject) => {
+      const req = indexedDB.open(this.database, this.version);
+      this.tables = tables.map((t) => {
+        t = typeof t == "object" ? t : { name: t };
+        return { ...t, name: t.name.toString() };
+      });
+      const tableNames = new ASet(this.tables.map((t) => t.name));
+      req.onerror = () => reject(req.error);
+      req.onsuccess = () => {
+        const db = req.result;
+        if (tableNames.symmetricDifference(new ASet(Array.from(db.objectStoreNames))).length) {
+          db.close();
+          Object.assign(this, new Database(this.database, this.tables, db.version + 1));
+        } else {
+          this.version = db.version;
+          resolve(db);
+        }
+      };
+      req.onupgradeneeded = () => {
+        const db = req.result;
+        const existingTables = new ASet(Array.from(db.objectStoreNames));
+        existingTables.difference(tableNames).forEach((name) => db.deleteObjectStore(name));
+        tableNames.difference(existingTables).forEach((name) => db.createObjectStore(name));
+      };
+    });
+  }
+  includes(name) {
+    return !!this.tables.find((t) => t.name == name.toString());
+  }
+  table(name) {
+    return new Table(this, name.toString());
+  }
+}
+class Table {
+  constructor(database, name) {
+    this.database = database;
+    this.name = name;
+  }
+  async tx(table, fn2, readonly = false) {
+    const db = await this.database.connection;
+    const tx = db.transaction(table, readonly ? "readonly" : "readwrite");
+    const store = tx.objectStore(table);
+    return new Promise((resolve, reject) => {
+      const request = fn2(store);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  add(value, key) {
+    return this.tx(this.name, (store) => store.add(value, key));
+  }
+  count() {
+    return this.tx(this.name, (store) => store.count(), true);
+  }
+  put(key, value) {
+    return this.tx(this.name, (store) => store.put(value, key));
+  }
+  getAll() {
+    return this.tx(this.name, (store) => store.getAll(), true);
+  }
+  getAllKeys() {
+    return this.tx(this.name, (store) => store.getAllKeys(), true);
+  }
+  get(key) {
+    return this.tx(this.name, (store) => store.get(key), true);
+  }
+  delete(key) {
+    return this.tx(this.name, (store) => store.delete(key));
+  }
+  clear() {
+    return this.tx(this.name, (store) => store.clear());
+  }
+}
 function contrast(background) {
   const exploded = background == null ? void 0 : background.match(background.length >= 6 ? /[0-9a-fA-F]{2}/g : /[0-9a-fA-F]/g);
   if (!exploded || (exploded == null ? void 0 : exploded.length) < 3) return "black";
@@ -1486,6 +1716,33 @@ var BehaviorSubject = function(_super) {
   };
   return BehaviorSubject2;
 }(Subject);
+var EmptyError = createErrorClass(function(_super) {
+  return function EmptyErrorImpl() {
+    _super(this);
+    this.name = "EmptyError";
+    this.message = "no elements in sequence";
+  };
+});
+function lastValueFrom(source, config2) {
+  return new Promise(function(resolve, reject) {
+    var _hasValue = false;
+    var _value;
+    source.subscribe({
+      next: function(value) {
+        _value = value;
+        _hasValue = true;
+      },
+      error: reject,
+      complete: function() {
+        if (_hasValue) {
+          resolve(_value);
+        } else {
+          reject(new EmptyError());
+        }
+      }
+    });
+  });
+}
 function filter(predicate, thisArg) {
   return operate(function(source, subscriber) {
     var index = 0;
@@ -1515,6 +1772,34 @@ function distinctUntilChanged(comparator, keySelector) {
 function defaultCompare(a, b) {
   return a === b;
 }
+function skip(count) {
+  return filter(function(_, index) {
+    return count <= index;
+  });
+}
+function takeWhile(predicate, inclusive) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      var result = predicate(value, index++);
+      (result || inclusive) && subscriber.next(value);
+      !result && subscriber.complete();
+    }));
+  });
+}
+async function getTheme(spoke, scope) {
+  let theme = await fetch(`https://${spoke}.auxiliumgroup.com/api/js/auxilium/dijits/templates/login/${spoke}/theme.json`).then((res) => res.json()).catch(() => null);
+  if (scope && theme != null && theme[scope]) theme = { ...theme, ...theme[scope] };
+  return {
+    found: !!theme,
+    background: `https://${spoke}.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/${spoke}/background.jpg`,
+    color: "#c83232",
+    logo: `https://${spoke}.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/${spoke}/logo.png`,
+    title: spoke.toUpperCase(),
+    textColor: "white",
+    ...theme || {}
+  };
+}
 const _LoginPrompt = class _LoginPrompt {
   constructor(api, spoke, options = {}) {
     __publicField(this, "alert");
@@ -1523,7 +1808,6 @@ const _LoginPrompt = class _LoginPrompt {
     __publicField(this, "password");
     __publicField(this, "persist");
     __publicField(this, "username");
-    __publicField(this, "options");
     __publicField(this, "_done");
     /** Promise which resolves once login is complete */
     __publicField(this, "done", new Promise((res) => {
@@ -1531,13 +1815,10 @@ const _LoginPrompt = class _LoginPrompt {
     }));
     this.api = api;
     this.spoke = spoke;
-    this.options = {
-      title: this.spoke,
-      background: "#ffffff",
-      color: "#c83232",
-      textColor: "#000000",
-      ...clean(options, true)
-    };
+    this.options = options;
+    this.themeDefaults().then(() => this.render());
+  }
+  async render() {
     this.close();
     document.head.innerHTML += _LoginPrompt.css(this.options);
     const div = document.createElement("div");
@@ -1549,9 +1830,17 @@ const _LoginPrompt = class _LoginPrompt {
     this.password = document.querySelector('#datalynk-login-form input[name="password"]');
     this.persist = document.querySelector('#datalynk-login-form input[name="persist"]');
     this.username = document.querySelector('#datalynk-login-form input[name="username"]');
-    if (options.persist === false) this.persist.parentElement.remove();
+    if (this.options.persist === false) this.persist.parentElement.remove();
     this.form.onsubmit = (event) => this.login(event);
   }
+  async themeDefaults() {
+    const theme = await getTheme(this.spoke, "login");
+    this.options = {
+      logoOnly: !this.options.title && !theme.found,
+      ...theme,
+      ...clean(this.options, true)
+    };
+  }
   /** Close the login prompt */
   close() {
     var _a, _b;
@@ -1597,11 +1886,11 @@ __publicField(_LoginPrompt, "css", (options) => `
 		@import url('https://fonts.cdnfonts.com/css/ar-blanca');
 		
 		#datalynk-login {
-			--theme-background: ${options.background};
+			--theme-background: ${options.backgroundColor ? options.backgroundColor : `url(${options.background})`};
 			--theme-container: #000000cc;
 			--theme-glow: ${options.glow || options.color};
 			--theme-primary: ${options.color};
-			--theme-text: ${options.textColor};;
+			--theme-text: ${options.textColor};
 			
 			position: fixed;
 			left: 0;
@@ -1614,7 +1903,7 @@ __publicField(_LoginPrompt, "css", (options) => `
 			font-family: sans-serif;
 			z-index: 1000;
 		}
-		
+
 		#datalynk-login .added-links {
 			color: var(--theme-text);
 			position: fixed;
@@ -1750,12 +2039,18 @@ __publicField(_LoginPrompt, "css", (options) => `
 /** Dynamically create HTML */
 __publicField(_LoginPrompt, "template", (options) => `
 	<div id="datalynk-login">
+		<!-- Used to check if image is valid -->
+		${!options.backgroundColor ? `
+		<img src="${options.background}" onerror="document.querySelector('#datalynk-login').style.backgroundImage = 'url(https://datalynk.auxiliumgroup.com/static/js/auxilium/dijits/templates/login/datalynk/background.jpg)'" style="width: 0; height: 0;"/>
+		` : ""}
+		
 		<div class="added-links">
 			${(options.addLinks || []).map((link) => `<a href="${link.url || "#"}" target="_blank">${link.text}</a>`).join(" | ")}
 		</div>
 		<div class="login-container">
 			<div class="login-header">
-				${options.title}
+				${options.logo ? `<img alt="Logo" src="${options.logo}" class="login-logo" style="height: 100px; width: auto;" onerror="this.style.display='none'" ${options.logoOnly ? `onload="document.querySelector('.login-title').remove()"` : ""}>` : ""}
+				<span class="login-title" style="margin-left: 0.5rem">${options.title}</span>
 			</div>
 			<div class="login-content">
 				<div class="login-body" style="max-width: 300px">
@@ -1801,13 +2096,17 @@ __publicField(_LoginPrompt, "template", (options) => `
 let LoginPrompt = _LoginPrompt;
 class Auth {
   constructor(api) {
+    __publicField(this, "onlinePrompt");
     /** Current user as an observable */
     __publicField(this, "user$", new BehaviorSubject(void 0));
+    var _a;
     this.api = api;
     this.api.token$.subscribe(async (token) => {
       if (token === void 0) return;
       this.user = await this.current(token);
     });
+    if ((_a = this.api.options.offline) == null ? void 0 : _a.length)
+      this.user$.pipe(filter((u) => u !== void 0)).subscribe((u) => localStorage.setItem("datalynk-user", JSON.stringify(u)));
   }
   /** Current user */
   get user() {
@@ -1830,7 +2129,9 @@ class Auth {
     var _a;
     if (!token) return null;
     else if (token == ((_a = this.user) == null ? void 0 : _a.token)) return this.user;
-    return this.api.request({ "$/auth/current": {} }, { token }).then((resp) => (resp == null ? void 0 : resp.login) ? resp : null);
+    else if (typeof navigator != "undefined" && !navigator.onLine && typeof localStorage != "undefined" && localStorage.getItem("datalynk-user"))
+      return JSON.parse(localStorage.getItem("datalynk-user"));
+    return this.api.request([{ "$/auth/current": {} }, { "$/env/me": {} }], { token }).then((resp) => resp[0] || resp[1] ? { ...resp[0], ...resp[1] } : null);
   }
   /**
    * Automatically handle sessions by checking localStorage & URL parameters for a token & prompting
@@ -1841,17 +2142,20 @@ class Auth {
    * @return {Promise<void>} Login complete
    */
   async handleLogin(spoke, options) {
-    var _a;
+    var _a, _b;
+    if (this.onlinePrompt) window.removeEventListener("online", this.onlinePrompt);
+    if ((_a = this.api.options.offline) == null ? void 0 : _a.length) window.removeEventListener("online", this.onlinePrompt = () => this.handleLogin(spoke, options));
     const urlToken = new URLSearchParams(location.search).get("datalynkToken");
     if (urlToken) {
       this.api.token = urlToken;
       location.href = location.href.replace(/datalynkToken=.*?(&|$)/gm, "");
-    } else if (this.api.token) {
-      if (((_a = this.api.jwtPayload) == null ? void 0 : _a.realm) != spoke) {
+    } else if (this.api.token && !this.api.expired) {
+      if (((_b = this.api.jwtPayload) == null ? void 0 : _b.realm) != spoke) {
         this.api.token = null;
         location.reload();
       }
     } else {
+      this.api.token = null;
       await this.loginPrompt(spoke, options).done;
       location.reload();
     }
@@ -1956,6 +2260,7 @@ class Auth {
    * @return {Promise<{closed: string, new: string}>}
    */
   logout() {
+    localStorage.removeItem("datalynk-user");
     return this.api.request({ "$/auth/logout": {} }).then((resp) => {
       this.api.token = null;
       return resp;
@@ -1970,11 +2275,13 @@ class Auth {
    * @return {Promise<any>} New session
    */
   reset(login, newPassword, code) {
-    return this.api.request({ "$/auth/mobile/rescue": {
-      user: login,
-      password: newPassword,
-      pin: code
-    } }).then((resp) => {
+    return this.api.request({
+      "$/auth/mobile/rescue": {
+        user: login,
+        password: newPassword,
+        pin: code
+      }
+    }).then((resp) => {
       if (resp.token) this.api.token = resp.token;
       return resp;
     });
@@ -2033,7 +2340,7 @@ class Files {
     })).then(async (files2) => {
       if (associate) {
         let id = typeof associate.row == "number" ? associate.row : associate.row[associate.pk || "id"];
-        if (!id) id = await this.api.slice(associate.slice).insert(associate.row).id();
+        if (!id) id = await this.api.slice(associate.slice).insert(associate.row).id().exec();
         await this.associate(files2.map((f2) => f2.id), associate == null ? void 0 : associate.slice, associate == null ? void 0 : associate.row, associate == null ? void 0 : associate.field);
       }
       return files2;
@@ -2193,23 +2500,13 @@ const Serializer = {
     }
   }
 };
-const _Slice = class _Slice {
-  /**
-   * An object to aid in constructing requests
-   *
-   * @param {number} slice Slice ID to interact with
-   * @param {Api} api Api to send the requests through
-   */
-  constructor(slice, api) {
+class ApiCall {
+  constructor(api, slice) {
     __publicField(this, "operation");
     __publicField(this, "popField");
     __publicField(this, "request", {});
     /** Log response automatically */
     __publicField(this, "debugging");
-    /** Unsubscribe from changes, undefined if not subscribed */
-    __publicField(this, "unsubscribe");
-    /** Cached slice data as an observable */
-    __publicField(this, "cache$", new BehaviorSubject([]));
     /**
      * Whitelist and alias fields. Alias of `fields()`
      * @example
@@ -2221,16 +2518,8 @@ const _Slice = class _Slice {
      * @return {Slice<T>}
      */
     __publicField(this, "alias", this.fields);
-    this.slice = slice;
     this.api = api;
-  }
-  /** Cached slice data */
-  get cache() {
-    return this.cache$.getValue();
-  }
-  /** Set cached data & alert subscribers */
-  set cache(cache) {
-    this.cache$.next(cache);
+    this.slice = slice;
   }
   /** Get raw API request */
   get raw() {
@@ -2325,7 +2614,8 @@ const _Slice = class _Slice {
    */
   exec(options) {
     if (!this.operation) throw new Error("No operation chosen");
-    return this.api.request(this.raw, options).then((resp) => {
+    const request = this.raw;
+    return this.api.request(request, options).then((resp) => {
       if (this.debugging) console.log(resp);
       return resp;
     });
@@ -2442,9 +2732,9 @@ const _Slice = class _Slice {
    * @param {T} rows Rows to add to slice
    * @returns {this<T>}
    */
-  save(...rows) {
+  save(rows) {
     this.operation = "$/slice/multisave";
-    this.request.rows = rows;
+    this.request.rows = makeArray(rows);
     return this;
   }
   /**
@@ -2465,30 +2755,6 @@ const _Slice = class _Slice {
     }
     return this;
   }
-  /**
-   * Synchronize cache with server
-   * @example
-   * ```ts
-   * const slice: Slice = new Slice<T>(Slices.Contact);
-   * slice.sync().subscribe((rows: T[]) => {});
-   * ```
-   * @param {boolean} on Enable/disable events
-   * @return {BehaviorSubject<T[]>} Cache which can be subscribed to
-   */
-  sync(on = true) {
-    if (on) {
-      new _Slice(this.slice, this.api).select().rows().exec().then((rows) => this.cache = rows);
-      if (!this.unsubscribe) this.unsubscribe = this.api.socket.sliceEvents(this.slice, (event) => {
-        const ids = [...event.data.new, ...event.data.changed];
-        new _Slice(this.slice, this.api).select(ids).rows().exec().then((rows) => this.cache = [...this.cache.filter((c) => c.id != null && !ids.includes(c.id)), ...rows]);
-        this.cache = this.cache.filter((v) => v.id && !event.data.lost.includes(v.id));
-      });
-      return this.cache$;
-    } else if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = null;
-    }
-  }
   /**
    * Set the request type to update
    * @example
@@ -2531,6 +2797,7 @@ const _Slice = class _Slice {
       Object.entries(field).forEach(([key, value2]) => this.where(key, "==", value2));
     } else {
       const w = raw ? field : [(() => {
+        if (operator == null ? void 0 : operator.startsWith("$")) return operator;
         if (operator == "==") return "$eq";
         if (operator == "!=") return "$neq";
         if (operator == ">") return "$gt";
@@ -2556,9 +2823,270 @@ const _Slice = class _Slice {
     }
     return this;
   }
-};
-__publicField(_Slice, "api");
-let Slice = _Slice;
+}
+class Slice {
+  /**
+   * An object to aid in constructing requests
+   *
+   * @param {number} slice Slice ID to interact with
+   * @param {Api} api Api to send the requests through
+   */
+  constructor(slice, api) {
+    __publicField(this, "table");
+    __publicField(this, "info");
+    __publicField(this, "pendingInsert", 0);
+    /** Unsubscribe from changes, undefined if not subscribed */
+    __publicField(this, "unsubscribe");
+    /** Cached slice data as an observable */
+    __publicField(this, "cache$", new BehaviorSubject([]));
+    var _a;
+    this.slice = slice;
+    this.api = api;
+    if (this.offlineEnabled) {
+      this.table = (_a = api.database) == null ? void 0 : _a.table(slice.toString());
+      this.table.getAll().then((resp) => this.cache = resp);
+      this.cache$.pipe(skip(1)).subscribe(async (cache) => {
+        var _a2;
+        await ((_a2 = this.table) == null ? void 0 : _a2.clear());
+        await Promise.all(cache.map((c) => {
+          var _a3;
+          return (_a3 = this.table) == null ? void 0 : _a3.put(c.id, c);
+        }));
+        this.fixIncrement();
+      });
+      this.sync();
+      window.addEventListener("online", async () => {
+        if (this.api.expired) await lastValueFrom(this.api.auth.user$.pipe(skip(1), takeWhile((u) => !u || this.api.expired, true)));
+        this.pushChanges();
+      });
+    }
+  }
+  /** Cached slice data */
+  get cache() {
+    return this.cache$.getValue();
+  }
+  /** Set cached data & alert subscribers */
+  set cache(cache) {
+    this.cache$.next(cache);
+  }
+  /** Is slice offline support enabled */
+  get offlineEnabled() {
+    var _a;
+    return (_a = this.api.database) == null ? void 0 : _a.includes(this.slice.toString());
+  }
+  fixIncrement() {
+    var _a;
+    this.pendingInsert = ((_a = this.cache.toSorted(sortByProp("id")).pop()) == null ? void 0 : _a["id"]) || 0;
+  }
+  execWrapper(call) {
+    const onlineExec = call.exec.bind(call);
+    return () => {
+      if (this.offlineEnabled && navigator && !(navigator == null ? void 0 : navigator.onLine)) {
+        const where = (row, condition) => {
+          if (Array.isArray(condition) ? !condition.length : condition == null) return true;
+          if (!Array.isArray(condition)) return condition;
+          if (condition[0] == "$field") return row[condition[1]];
+          if (condition[0] == "$not") return !where(row, condition.slice(1));
+          if (condition[0] == "$and") return condition.slice(1).filter((v) => where(row, v)).length == condition.length - 1;
+          if (condition[0] == "$or") return !!condition.slice(1).find((v) => where(row, v));
+          if (condition[0] == "$eq") return where(row, condition[1]) == where(row, condition[2]);
+          if (condition[0] == "$neq") return where(row, condition[1]) != where(row, condition[2]);
+          if (condition[0] == "$gt") return where(row, condition[1]) > where(row, condition[2]);
+          if (condition[0] == "$gte") return where(row, condition[1]) >= where(row, condition[2]);
+          if (condition[0] == "$lt") return where(row, condition[1]) < where(row, condition[2]);
+          if (condition[0] == "$lte") return where(row, condition[1]) <= where(row, condition[2]);
+          if (condition[0] == "$mod") return where(row, condition[1]) % where(row, condition[2]);
+          return condition[0];
+        };
+        let request = call.raw, resp = {};
+        if (request["$/slice/delete"]) {
+          const found = this.cache.filter((r) => where(r, request["$/slice/delete"]["where"])).map((r) => r.id);
+          this.cache = this.cache.map((r) => found.includes(r.id) ? { ...r, _sync: "delete" } : r);
+          resp = {
+            affected: found.length,
+            "ignored-keys": [],
+            keys: found,
+            tx: null
+          };
+        } else if (request["$/slice/report"]) {
+          resp["rows"] = deepCopy(this.cache).filter((r) => (r == null ? void 0 : r._sync) != "delete").filter((r) => r && where(r, request["$/slice/report"]["where"]));
+          if (request["order"]) resp["rows"] = resp["rows"].toSorted(sortByProp(request["order"][1][1], request["order"] == "$desc"));
+          if (request["limit"]) resp["rows"] = resp["rows"].slice(0, request["limit"]);
+          if (request["fields"]) {
+            if (request["fields"]["$count"]) resp["rows"] = { count: resp["rows"].length };
+            else resp["rows"] = resp["rows"].map((r) => Object.entries(request["fields"]).reduce((acc, [k, v]) => ({
+              ...acc,
+              [v]: r[k]
+            }), {}));
+          }
+        } else if (request["$/slice/xinsert"]) {
+          const rows = request["$/slice/xinsert"]["rows"].map((r) => ({
+            ...r,
+            id: -++this.pendingInsert,
+            _sync: "insert"
+          }));
+          this.cache = [...this.cache, ...rows];
+          resp = {
+            failed: [],
+            granted: rows.map((r) => Object.keys(r).reduce((acc, key) => ({ ...acc, [key]: true }), {})),
+            "ignored-fields": [],
+            keys: rows.map((r) => r.id),
+            publish: 1,
+            tx: null
+          };
+        } else if (request["$/slice/xupdate"]) {
+          const ids = request["$/slice/xupdate"]["rows"].map((r) => r.id);
+          this.cache = [
+            ...this.cache.filter((c) => !ids.includes(c.id)),
+            ...request["$/slice/xupdate"]["rows"].map((r) => ({ ...r, _sync: "update" }))
+          ].toSorted(sortByProp("id"));
+          resp = {
+            failed: [],
+            granted: request["$/slice/xupdate"]["rows"].map((r) => Object.keys(r).reduce((acc, key) => ({
+              ...acc,
+              [key]: true
+            }), {})),
+            "ignored-fields": [],
+            keys: request["$/slice/xupdate"]["rows"].map((r) => r.id),
+            publish: 1,
+            tx: null
+          };
+        }
+        if (request["$pop"]) {
+          resp = request["$pop"].split(":").reduce((acc, key) => acc[JSONAttemptParse(key)], resp);
+        }
+        return Promise.resolve(resp);
+      } else {
+        return onlineExec();
+      }
+    };
+  }
+  async pushChanges() {
+    if (this.offlineEnabled && navigator && navigator.onLine) {
+      await Promise.allSettled(
+        this.cache.values().map((value) => {
+          if (value._sync == "delete") {
+            return this.delete(value.id).exec();
+          } else if (value._sync == "insert") {
+            return this.insert({ ...value, id: void 0, _sync: void 0 }).exec();
+          } else if (value._sync == "update") {
+            return this.update({
+              ...value,
+              _sync: void 0
+            }).where("_updatedDate", "==", value.modified).exec();
+          }
+        }).filter((r) => !!r)
+      );
+    }
+  }
+  /**
+   * Get slice information
+   * @param reload Ignore cache & reload info
+   * @return {Promise<SliceInfo>}
+   */
+  async getInfo(reload) {
+    var _a, _b, _c;
+    const getType = (field) => {
+      if (field.options) {
+        let t = field.options.split("|").map((o) => `'${o}'`).join(" | ");
+        if (field.type == "control_checkbox") t = `(${t})[]`;
+        return t;
+      }
+      if (field.type == "control_checkbox" || field.type == "boolean") return "boolean";
+      if (field.type == "control_new_date" || field.type == "control_new_time" || field.type == "control_new_datetime" || field.type == "Date")
+        return "Date";
+      if (field.type == "control_number" || field.type == "number") return "number";
+      return "string";
+    };
+    if (this.info && !reload) return Promise.resolve(this.info);
+    this.info = await this.api.request({ "$/slice/fetch": { slice: this.slice } });
+    const fields = ((_c = (_b = (_a = this.info) == null ? void 0 : _a.meta) == null ? void 0 : _b.presentation) == null ? void 0 : _c.fields) ? Object.values(this.info.meta.presentation.fields) : [];
+    this.info.types = fields.filter((value) => value.id != void 0).map((value) => {
+      var _a2;
+      return {
+        key: value.id.toString(),
+        options: (_a2 = value.options) == null ? void 0 : _a2.split("|"),
+        readonly: !!value.readonly || value.id.startsWith("fid") || ["id", "creatorRef", "created", "modifierRef", "modified"].includes(value.id),
+        required: !!value.required,
+        type: getType(value)
+      };
+    });
+    return this.info;
+  }
+  /**
+   * Synchronize cache with server
+   * @example
+   * ```ts
+   * const slice: Slice = new Slice<T>(Slices.Contact);
+   * slice.sync().subscribe((rows: T[]) => {});
+   * ```
+   * @param {boolean} on Enable/disable events
+   * @return {BehaviorSubject<T[]>} Cache which can be subscribed to
+   */
+  sync(on = true) {
+    if (on) {
+      this.pushChanges().then(() => this.select().rows().exec().then((rows) => this.cache = rows));
+      if (!this.unsubscribe) this.unsubscribe = this.api.socket.sliceEvents(this.slice, (event) => {
+        const ids = [...event.data.new, ...event.data.changed];
+        this.select(ids).rows().exec().then((rows) => this.cache = [...this.cache.filter((c) => c.id != null && !ids.includes(c.id)), ...rows]);
+        this.cache = this.cache.filter((v) => v.id && !event.data.lost.includes(v.id));
+      });
+      return this.cache$;
+    } else if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+  }
+  // Transaction wrapper =============================================================================================
+  /**
+   * {@inheritDoc ApiCall.count}
+   */
+  count(arg = "id") {
+    const call = new ApiCall(this.api, this.slice);
+    call.exec = this.execWrapper(call);
+    return call.count(arg);
+  }
+  /**
+   * {@inheritDoc ApiCall.delete}
+   */
+  delete(id) {
+    const call = new ApiCall(this.api, this.slice);
+    call.exec = this.execWrapper(call);
+    return call.delete(id);
+  }
+  /**
+   * {@inheritDoc ApiCall.insert}
+   */
+  insert(rows) {
+    const call = new ApiCall(this.api, this.slice);
+    call.exec = this.execWrapper(call);
+    return call.insert(rows);
+  }
+  /**
+   * {@inheritDoc ApiCall.save}
+   */
+  save(rows) {
+    const call = new ApiCall(this.api, this.slice);
+    call.exec = this.execWrapper(call);
+    return call.save(rows);
+  }
+  /**
+   * {@inheritDoc ApiCall.select}
+   */
+  select(id) {
+    const call = new ApiCall(this.api, this.slice);
+    call.exec = this.execWrapper(call);
+    return call.select(id);
+  }
+  /**
+   * {@inheritDoc ApiCall.update}
+   */
+  update(rows) {
+    const call = new ApiCall(this.api, this.slice);
+    call.exec = this.execWrapper(call);
+    return call.update(rows);
+  }
+}
 class Socket {
   constructor(api, options = {}) {
     __publicField(this, "listeners", []);
@@ -2691,8 +3219,8 @@ class Superuser {
     } });
   }
 }
-const version = "1.0.20";
-class Api {
+const version = "1.1.0-rc1";
+const _Api = class _Api {
   /**
    * Connect to Datalynk & send requests
    *
@@ -2701,10 +3229,10 @@ class Api {
    * const api = new Api('https://spoke.auxiliumgroup.com');
    * ```
    *
-   * @param {string} url API URL
+   * @param {string} origin API URL
    * @param {ApiOptions} options
    */
-  constructor(url, options = {}) {
+  constructor(origin, options = {}) {
     /** Current requests bundle */
     __publicField(this, "bundle", []);
     /** Bundle lifecycle tracking */
@@ -2713,12 +3241,6 @@ class Api {
     __publicField(this, "localStorageKey", "datalynk-token");
     /** Pending requests cache */
     __publicField(this, "pending", {});
-    /** API URL */
-    __publicField(this, "url");
-    /** Package version */
-    __publicField(this, "version", version);
-    /** API Session token */
-    __publicField(this, "token$", new BehaviorSubject(void 0));
     /** Helpers */
     /** Authentication */
     __publicField(this, "auth");
@@ -2730,12 +3252,26 @@ class Api {
     __publicField(this, "socket");
     /** Superuser */
     __publicField(this, "superuser");
-    this.options = options;
-    this.url = `${new URL(url).origin}/api/`;
+    /** Offline database */
+    __publicField(this, "database");
+    /** Options */
+    __publicField(this, "options");
+    /** Created slices */
+    __publicField(this, "sliceCache", /* @__PURE__ */ new Map());
+    /** API URL */
+    __publicField(this, "url");
+    /** Client library version */
+    __publicField(this, "version", version);
+    /** API Session token */
+    __publicField(this, "token$", new BehaviorSubject(void 0));
+    var _a, _b;
+    this.origin = origin;
+    this.url = `${new URL(origin).origin}/api/`;
     this.options = {
-      bundleTime: 100,
+      offline: [],
       origin: typeof location !== "undefined" ? location.host : "Unknown",
       saveSession: true,
+      serviceWorker: "/service.worker.js",
       ...options
     };
     if (this.options.saveSession) {
@@ -2746,12 +3282,32 @@ class Api {
         else localStorage.removeItem(this.localStorageKey);
       });
     }
-    Slice.api = this;
+    this.socket = new Socket(this, { url: options.socket });
     this.auth = new Auth(this);
     this.files = new Files(this);
     this.pdf = new Pdf(this);
     this.superuser = new Superuser(this);
-    this.socket = new Socket(this, { url: options.socket });
+    if ((_a = this.options.offline) == null ? void 0 : _a.length) {
+      if (typeof indexedDB == "undefined") throw new Error("Cannot enable offline support, indexedDB is not available in this environment");
+      this.database = new Database("datalynk", this.options.offline);
+      (_b = this.options.offline) == null ? void 0 : _b.forEach((id) => this.slice(id));
+      this.cacheUrl();
+    }
+  }
+  /** Get session info from JWT payload */
+  get jwtPayload() {
+    if (!this.token) return null;
+    return decodeJwt(this.token);
+  }
+  /** Is token expired */
+  get expired() {
+    var _a;
+    return (((_a = this.jwtPayload) == null ? void 0 : _a.exp) ?? Infinity) * 1e3 <= Date.now();
+  }
+  /** Logged in spoke */
+  get spoke() {
+    var _a;
+    return (_a = this.jwtPayload) == null ? void 0 : _a.realm;
   }
   get token() {
     return this.token$.getValue();
@@ -2759,11 +3315,6 @@ class Api {
   set token(token) {
     this.token$.next(token);
   }
-  /** Get session info from JWT payload */
-  get jwtPayload() {
-    if (!this.token) return null;
-    return decodeJwt(this.token);
-  }
   _request(req, options = {}) {
     const token = options.token || this.token;
     return fetch(this.url, {
@@ -2773,14 +3324,31 @@ class Api {
         "Content-Type": "application/json",
         "X-Date-Return-Format": this.options.legacyDates ? void 0 : "ISO8601"
       }),
-      body: JSON.stringify(Api.translateTokens(req))
+      body: JSON.stringify(_Api.translateTokens(req))
     }).then(async (resp) => {
       let data = JSONAttemptParse(await resp.text());
       if (!resp.ok || (data == null ? void 0 : data.error)) throw Object.assign(errorFromCode(resp.status, data.error), data);
-      if (!options.raw) data = Api.translateTokens(data);
+      if (!options.raw) data = _Api.translateTokens(data);
       return data;
     });
   }
+  async cacheUrl() {
+    if (!this.options.serviceWorker || !("serviceWorker" in navigator)) return;
+    await navigator.serviceWorker.getRegistration(this.options.serviceWorker).then((reg) => reg ?? navigator.serviceWorker.register(this.options.serviceWorker, { scope: "/" }));
+    await navigator.serviceWorker.ready;
+    if (!navigator.serviceWorker.controller) return window.location.reload();
+  }
+  /**
+   * Get list of slices
+   * @return {Promise<number[]>}
+   */
+  getSlices() {
+    return this.request({ "$/tools/action_chain": [
+      { "!/env/me": {} },
+      { "!/slice/permissionsLite": {} },
+      { "!/tools/column": { "col": "id", "rows": { "$_": "1:rows" } } }
+    ] });
+  }
   /**
    * Parses API request/response object for special Datalynk tokens & converts them to native JS objects
    *
@@ -2799,6 +3367,10 @@ class Api {
             val = Serializer.deserialize[index](val[index]);
           } else if (index in Serializer.serialize) {
             val = Serializer.serialize[index](val[index]);
+          } else if (val[index] == "Yes") {
+            val[index] = true;
+          } else if (val[index] == "No") {
+            val[index] = false;
           } else {
             queue.push(`${key}.${index}`);
           }
@@ -2815,7 +3387,7 @@ class Api {
   chain(...requests) {
     const arr = requests.length == 1 && Array.isArray(requests[0]) ? requests[0] : requests;
     return this.request({ "$/tools/action_chain": arr.map((r) => {
-      if (!(r instanceof Slice)) return r;
+      if (!(r instanceof ApiCall)) return r;
       const req = r.raw;
       Object.keys(req).forEach((key) => {
         if (key.startsWith("$/")) {
@@ -2834,7 +3406,7 @@ class Api {
   chainMap(request) {
     return this.request({ "$/tools/do": [
       ...Object.entries(request).flatMap(([key, r]) => {
-        if (!(r instanceof Slice)) return [key, r];
+        if (!(r instanceof ApiCall)) return [key, r];
         const req = r.raw;
         Object.keys(req).forEach((key2) => {
           if (key2.startsWith("$/")) {
@@ -2915,15 +3487,20 @@ class Api {
    * const unsubscribe = contactsSlice.sync().subscribe(rows => console.log(rows));
    * ```
    *
-   * @param {number} slice Slice number the object will target
+   * @param {number} id Slice ID the object will target
    * @returns {Slice<T = any>} Object for making requests & caching rows
    */
-  slice(slice) {
-    return new Slice(slice, this);
+  slice(id) {
+    if (!this.sliceCache.has(+id)) this.sliceCache.set(+id, new Slice(id, this));
+    return this.sliceCache.get(+id);
   }
-}
+};
+/** Client library version */
+__publicField(_Api, "version", version);
+let Api = _Api;
 export {
   Api,
+  ApiCall,
   Auth,
   Files,
   LoginPrompt,
@@ -2931,5 +3508,6 @@ export {
   Serializer,
   Slice,
   Socket,
-  Superuser
+  Superuser,
+  getTheme
 };