@uwdata/mosaic-core 0.1.0 → 0.3.0

package/src/util/synchronizer.js

@@ -0,0 +1,47 @@
+/**
+ * Create a new synchronizer instance to aid synchronization
+ * of updates on multiple pending operations.
+ */
+export function synchronizer() {
+  const set = new Set;
+  let done;
+  let promise = new Promise(resolve => done = resolve);
+
+  return {
+    /**
+     * Mark an item as pending.
+     * @param {*} item An item to synchronize on.
+     */
+    pending(item) {
+      set.add(item);
+    },
+    /**
+     * Mark a pending item as ready, indicating it is
+     * ready for a synchronized update.
+     * @param {*} item An item to synchronize on.
+     * @returns {boolean} True if the synchronizer is ready to
+     *  resolve, false otherwise.
+     */
+    ready(item) {
+      set.delete(item);
+      return set.size === 0;
+    },
+    /**
+     * Resolve the current synchronization cycle, causing the synchronize
+     * promise to resolve and thereby trigger downstream updates.
+     */
+    resolve() {
+      promise = new Promise(resolve => {
+        done();
+        done = resolve;
+      });
+    },
+    /**
+     * The promise for the current synchronization cycle.
+     * @return {Promise} The synchronization promise.
+     */
+    get promise() {
+      return promise;
+    }
+  }
+}

package/src/QueryCache.js

@@ -1,65 +0,0 @@
-const requestIdle = typeof requestIdleCallback !== 'undefined'
-  ? requestIdleCallback
-  : setTimeout;
-
-export const voidCache = () => ({
-  get: () => undefined,
-  set: (key, result) => result,
-  clear: () => {}
-});
-
-export class QueryCache {
-  constructor({
-    max = 1000, // max entries
-    ttl = 3 * 60 * 60 * 1000 // time-to-live, default 3 hours
-  } = {}) {
-    this.max = max;
-    this.ttl = ttl;
-    this.clear();
-  }
-
-  clear() {
-    this.cache = new Map();
-  }
-
-  get(key) {
-    const entry = this.cache.get(key);
-    if (entry) {
-      entry.last = performance.now();
-      return entry.promise;
-    }
-  }
-
-  set(key, promise) {
-    const { cache, max } = this;
-    cache.set(key, { last: performance.now(), promise });
-    if (cache.size > max) requestIdle(() => this.evict());
-    return promise;
-  }
-
-  evict() {
-    const expire = performance.now() - this.ttl;
-    let lruKey = null;
-    let lruLast = Infinity;
-
-    for (const [key, value] of this.cache) {
-      const { last } = value;
-
-      // least recently used entry seen so far
-      if (last < lruLast) {
-        lruKey = key;
-        lruLast = last;
-      }
-
-      // remove if time since last access exceeds ttl
-      if (expire > last) {
-        this.cache.delete(key);
-      }
-    }
-
-    // remove lru entry
-    if (lruKey) {
-      this.cache.delete(lruKey);
-    }
-  }
-}

package/src/util/skip-client.js

@@ -1,3 +0,0 @@
-export function skipClient(client, clause) {
-  return clause?.clients?.has(client);
-}

package/src/util/sql-from.js

@@ -1,22 +0,0 @@
-import { literalToSQL } from '@uwdata/mosaic-sql';
-
-export function sqlFrom(data, {
-  columns = Object.keys(data?.[0] || {})
-} = {}) {
-  let keys = [];
-  if (Array.isArray(columns)) {
-    keys = columns;
-    columns = keys.reduce((m, k) => (m[k] = k, m), {});
-  } else if (columns) {
-    keys = Object.keys(columns);
-  }
-  if (!keys.length) {
-    throw new Error('Can not create table from empty column set.');
-  }
-  const subq = [];
-  for (const datum of data) {
-    const sel = keys.map(k => `${literalToSQL(datum[k])} AS "${columns[k]}"`);
-    subq.push(`(SELECT ${sel.join(', ')})`);
-  }
-  return subq.join(' UNION ALL ');
-}