@gorgonjs/gorgon 1.5.1 → 1.6.1

package/coverage/sorter.js

@@ -1,196 +0,0 @@
-/* eslint-disable */
-var addSorting = (function() {
-    'use strict';
-    var cols,
-        currentSort = {
-            index: 0,
-            desc: false
-        };
-
-    // returns the summary table element
-    function getTable() {
-        return document.querySelector('.coverage-summary');
-    }
-    // returns the thead element of the summary table
-    function getTableHeader() {
-        return getTable().querySelector('thead tr');
-    }
-    // returns the tbody element of the summary table
-    function getTableBody() {
-        return getTable().querySelector('tbody');
-    }
-    // returns the th element for nth column
-    function getNthColumn(n) {
-        return getTableHeader().querySelectorAll('th')[n];
-    }
-
-    function onFilterInput() {
-        const searchValue = document.getElementById('fileSearch').value;
-        const rows = document.getElementsByTagName('tbody')[0].children;
-        for (let i = 0; i < rows.length; i++) {
-            const row = rows[i];
-            if (
-                row.textContent
-                    .toLowerCase()
-                    .includes(searchValue.toLowerCase())
-            ) {
-                row.style.display = '';
-            } else {
-                row.style.display = 'none';
-            }
-        }
-    }
-
-    // loads the search box
-    function addSearchBox() {
-        var template = document.getElementById('filterTemplate');
-        var templateClone = template.content.cloneNode(true);
-        templateClone.getElementById('fileSearch').oninput = onFilterInput;
-        template.parentElement.appendChild(templateClone);
-    }
-
-    // loads all columns
-    function loadColumns() {
-        var colNodes = getTableHeader().querySelectorAll('th'),
-            colNode,
-            cols = [],
-            col,
-            i;
-
-        for (i = 0; i < colNodes.length; i += 1) {
-            colNode = colNodes[i];
-            col = {
-                key: colNode.getAttribute('data-col'),
-                sortable: !colNode.getAttribute('data-nosort'),
-                type: colNode.getAttribute('data-type') || 'string'
-            };
-            cols.push(col);
-            if (col.sortable) {
-                col.defaultDescSort = col.type === 'number';
-                colNode.innerHTML =
-                    colNode.innerHTML + '<span class="sorter"></span>';
-            }
-        }
-        return cols;
-    }
-    // attaches a data attribute to every tr element with an object
-    // of data values keyed by column name
-    function loadRowData(tableRow) {
-        var tableCols = tableRow.querySelectorAll('td'),
-            colNode,
-            col,
-            data = {},
-            i,
-            val;
-        for (i = 0; i < tableCols.length; i += 1) {
-            colNode = tableCols[i];
-            col = cols[i];
-            val = colNode.getAttribute('data-value');
-            if (col.type === 'number') {
-                val = Number(val);
-            }
-            data[col.key] = val;
-        }
-        return data;
-    }
-    // loads all row data
-    function loadData() {
-        var rows = getTableBody().querySelectorAll('tr'),
-            i;
-
-        for (i = 0; i < rows.length; i += 1) {
-            rows[i].data = loadRowData(rows[i]);
-        }
-    }
-    // sorts the table using the data for the ith column
-    function sortByIndex(index, desc) {
-        var key = cols[index].key,
-            sorter = function(a, b) {
-                a = a.data[key];
-                b = b.data[key];
-                return a < b ? -1 : a > b ? 1 : 0;
-            },
-            finalSorter = sorter,
-            tableBody = document.querySelector('.coverage-summary tbody'),
-            rowNodes = tableBody.querySelectorAll('tr'),
-            rows = [],
-            i;
-
-        if (desc) {
-            finalSorter = function(a, b) {
-                return -1 * sorter(a, b);
-            };
-        }
-
-        for (i = 0; i < rowNodes.length; i += 1) {
-            rows.push(rowNodes[i]);
-            tableBody.removeChild(rowNodes[i]);
-        }
-
-        rows.sort(finalSorter);
-
-        for (i = 0; i < rows.length; i += 1) {
-            tableBody.appendChild(rows[i]);
-        }
-    }
-    // removes sort indicators for current column being sorted
-    function removeSortIndicators() {
-        var col = getNthColumn(currentSort.index),
-            cls = col.className;
-
-        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
-        col.className = cls;
-    }
-    // adds sort indicators for current column being sorted
-    function addSortIndicators() {
-        getNthColumn(currentSort.index).className += currentSort.desc
-            ? ' sorted-desc'
-            : ' sorted';
-    }
-    // adds event listeners for all sorter widgets
-    function enableUI() {
-        var i,
-            el,
-            ithSorter = function ithSorter(i) {
-                var col = cols[i];
-
-                return function() {
-                    var desc = col.defaultDescSort;
-
-                    if (currentSort.index === i) {
-                        desc = !currentSort.desc;
-                    }
-                    sortByIndex(i, desc);
-                    removeSortIndicators();
-                    currentSort.index = i;
-                    currentSort.desc = desc;
-                    addSortIndicators();
-                };
-            };
-        for (i = 0; i < cols.length; i += 1) {
-            if (cols[i].sortable) {
-                // add the click event handler on the th so users
-                // dont have to click on those tiny arrows
-                el = getNthColumn(i).querySelector('.sorter').parentElement;
-                if (el.addEventListener) {
-                    el.addEventListener('click', ithSorter(i));
-                } else {
-                    el.attachEvent('onclick', ithSorter(i));
-                }
-            }
-        }
-    }
-    // adds sorting functionality to the UI
-    return function() {
-        if (!getTable()) {
-            return;
-        }
-        cols = loadColumns();
-        loadData();
-        addSearchBox();
-        addSortIndicators();
-        enableUI();
-    };
-})();
-
-window.addEventListener('load', addSorting);

package/index.ts

@@ -1,317 +0,0 @@
-import MemoryCache from './provider/memory';
-
-export type asyncFunction = () => Promise<any> | (() => any);
-export type GorgonHookKey =
-  | 'settings'
-  | 'addProvider'
-  | 'put'
-  | 'clear'
-  | 'clearAll'
-  | 'overwrite'
-  | 'get'
-  | 'valueError';
-export type GorgonHook = (key: GorgonHookKey, input?: any, output?: any) => void;
-export type GorgonSettings = {
-  debug: boolean;
-  defaultProvider: string;
-  retry: number;
-};
-export type GorgonSettingsInput = {
-  debug?: boolean;
-  defaultProvider?: string;
-  retry?: number;
-};
-export type GorgonPolicy = {
-  expiry: number | Date | false;
-  provider: string;
-};
-export type GorgonPolicyInput = GorgonPolicy | number | Date;
-export type GorgonPolicySanitized = {
-  expiry: number | false;
-  provider: string;
-};
-type GorgonCurrentTaskItem = Array<{
-  res?: any;
-  rej?: any;
-  queued: Date;
-}>;
-export interface IGorgonCacheProvider {
-  init: () => Promise<void>;
-  get: (key: string) => Promise<any>;
-  set: <R>(key: string, value: R, policy: GorgonPolicySanitized) => Promise<R>;
-  clear: (key?: string) => Promise<boolean>;
-  keys: () => Promise<string[]>;
-}
-
-const Gorgon = (() => {
-  const currentTasks = {} as { [key: string]: GorgonCurrentTaskItem };
-  const hOP = currentTasks.hasOwnProperty;
-
-  const settings = {
-    debug: false,
-    defaultProvider: 'memory',
-    retry: 5000,
-  } as GorgonSettings;
-
-  const policyMaker = function (incPolicy?: GorgonPolicyInput) {
-    const outPolicy = {
-      expiry: false,
-      provider: settings.defaultProvider,
-    } as GorgonPolicySanitized;
-
-    // Blank policy, false, or no policy. lets store forever
-    if (!incPolicy) {
-      return outPolicy;
-    }
-
-    // Type is a full policy object
-    if (incPolicy instanceof Date) {
-      var d = new Date();
-
-      outPolicy.expiry = Math.ceil((incPolicy.getTime() - d.getTime()) / 1000);
-    } else if (typeof incPolicy === 'object' && incPolicy.expiry) {
-      if (incPolicy.expiry instanceof Date) {
-        outPolicy.expiry = Math.ceil((incPolicy.expiry.getTime() - d.getTime()) / 1000);
-      } else {
-        outPolicy.expiry = incPolicy.expiry;
-      }
-      outPolicy.provider = incPolicy.provider || outPolicy.provider;
-    } else if (typeof incPolicy === 'object') {
-      outPolicy.provider = incPolicy.provider || outPolicy.provider;
-    } else if (typeof incPolicy === 'number') {
-      outPolicy.expiry = incPolicy;
-    }
-
-    // Number is too small, negative or not a number
-    outPolicy.expiry = outPolicy.expiry && outPolicy.expiry > 0 ? outPolicy.expiry : false;
-
-    return outPolicy;
-  };
-
-  const gorgonCore = {
-    // Providers available for use
-    providers: {} as { [key: string]: IGorgonCacheProvider },
-
-    // Hooks
-    hooks: {} as { [key: string]: Array<GorgonHook> },
-
-    _callHooks: (key: GorgonHookKey, input?: any, output?: any) => {
-      if (hOP.call(gorgonCore.hooks, key)) {
-        for (var i in gorgonCore.hooks[key]) {
-          if (typeof gorgonCore.hooks[key][i] === 'function') {
-            try {
-              gorgonCore.hooks[key][i](key, input, output);
-            } catch (e) {
-              console.error('[Gorgon] Hook error for hook: ' + key, e);
-            }
-          }
-        }
-      }
-    },
-
-    // Allows for settings on the gorgon cache
-    settings: (newSettings?: GorgonSettingsInput) => {
-      if (!newSettings) {
-        return settings;
-      }
-
-      Object.assign(settings, newSettings); // only overwrite ones sent in; keep others at existing
-
-      gorgonCore._callHooks('settings', newSettings, settings);
-
-      return settings;
-    },
-
-    // add a hook or array of hooks
-    addHook: (key: GorgonHookKey, hook: GorgonHook | Array<GorgonHook>) => {
-      if (!hOP.call(gorgonCore.hooks, key)) {
-        gorgonCore.hooks[key] = [];
-      }
-
-      if (Array.isArray(hook)) {
-        gorgonCore.hooks[key] = gorgonCore.hooks[key].concat(hook);
-      } else {
-        gorgonCore.hooks[key].push(hook);
-      }
-    },
-
-    // Add a provider
-    addProvider: (name: string, provider: IGorgonCacheProvider) => {
-      provider.init(); // Trigger for provider to clear any old cache items or any other cleanup
-      gorgonCore.providers[name] = provider;
-
-      gorgonCore._callHooks('addProvider', { name, provider });
-    },
-
-    // Place an item into the cache
-    put: async <R>(key: string, value: R, policy?: GorgonPolicyInput): Promise<R> => {
-      policy = policyMaker(policy);
-      var prov = gorgonCore.providers[policy.provider];
-
-      gorgonCore._callHooks('put', { key, value, policy }, value);
-
-      return prov.set(key, value, policyMaker(policy));
-    },
-
-    // Clear one or all items in the cache
-    clear: async (key: string, provider?: string, hookIdentifier?: string) => {
-      var prov = gorgonCore.providers[provider || settings.defaultProvider];
-
-      gorgonCore._callHooks('clear', { key, provider, identifier: hookIdentifier });
-
-      // Clear a wildcard search of objects
-      if (key && key.indexOf('*') > -1) {
-        return prov.keys().then(function (keys) {
-          var cacheMatchKeys = keys.filter(function (str) {
-            return new RegExp('^' + key.split('*').join('.*') + '$').test(str);
-          });
-
-          var clearPromises = cacheMatchKeys.map(prov.clear);
-          // Incase someone somehow used a wildcard in their cached key (don't do this)
-
-          clearPromises.push(prov.clear(key));
-          return Promise.all(clearPromises);
-        });
-      }
-
-      // Not a special clear
-      return prov.clear(key);
-    },
-
-    // Clear all keys/values in the cache
-    clearAll: async (provider?: string, hookIdentifier?: string) => {
-      var prov = gorgonCore.providers[provider || settings.defaultProvider];
-
-      gorgonCore._callHooks('clearAll', { provider, identifier: hookIdentifier });
-
-      return prov.clear();
-    },
-
-    // Allows you to instantly overwite a cache object
-    overwrite: async (key: string, asyncFunc: asyncFunction, policy?: GorgonPolicyInput) => {
-      try {
-        const resolvedData = await asyncFunc();
-
-        const val = await gorgonCore.put(key, resolvedData, policyMaker(policy));
-
-        gorgonCore._callHooks('overwrite', { key, asyncFunc, policy }, val);
-
-        return val;
-      } catch (e) {
-        throw e;
-      }
-    },
-
-    // Allows you to get from the cache or pull from the promise
-    get: async <R>(key: string, asyncFunc: () => R, policy?: GorgonPolicyInput): Promise<R> => {
-      policy = policyMaker(policy);
-      const prov = gorgonCore.providers[policy.provider];
-
-      const currentVal = await prov.get(key); // Most providers will only lookup by key and return false on not found
-
-      // If we have a current value sent it out; cache hit!
-      if (currentVal !== undefined) {
-        if (settings.debug) {
-          console.info('[Gorgon] Cache hit for key: ' + key, currentVal);
-        }
-
-        gorgonCore._callHooks('get', { key, asyncFunc, policy, cacheHit: true, queued: false }, currentVal);
-
-        return currentVal;
-      }
-
-      // Are we currently already running this cache item?
-      if (hOP.call(currentTasks, key) && Array.isArray(currentTasks[key]) && currentTasks[key].length > 0) {
-        // Add to the current task, but ignore if any items is below retry anyway threshold
-        var oldQueue = false;
-
-        for (var i in currentTasks[key]) {
-          if (currentTasks[key][i].queued < new Date(Date.now() - settings.retry)) {
-            oldQueue = true;
-          }
-        }
-
-        // Add to the current queue
-        if (!oldQueue) {
-          if (settings.debug) {
-            console.info('[Gorgon] Cache miss, in progress, adding to current queue for key: ' + key);
-          }
-
-          var concurent = new Promise(function (resolve: (value: R) => void, reject) {
-            currentTasks[key].push({
-              res: resolve,
-              rej: reject,
-              queued: new Date(),
-            });
-          });
-
-          gorgonCore._callHooks('get', { key, asyncFunc, policy, cacheHit: false, queued: true }, concurent);
-
-          return concurent;
-        }
-      } else {
-        // Add current task to list, this is the first one so the primary
-        currentTasks[key] = [{ queued: new Date() }];
-      }
-
-      try {
-        if (settings.debug) {
-          console.info('[Gorgon] Cache miss, resolving item for: ' + key);
-        }
-
-        // This is the primary item
-        const resolver = asyncFunc();
-
-        gorgonCore._callHooks('get', { key, asyncFunc, policy, cacheHit: false, queued: false }, resolver);
-
-        // wait for it to finish then push it out
-        const resolvedData = await resolver;
-
-        if (settings.debug) {
-          console.info('[Gorgon] Cache resolved, resolved item for: ' + key, resolvedData);
-        }
-
-        const val = await gorgonCore.put(key, resolvedData, policyMaker(policy));
-
-        if (hOP.call(currentTasks, key)) {
-          for (var i in currentTasks[key]) {
-            if (currentTasks[key][i].res) {
-              if (settings.debug) {
-                console.info('[Gorgon] Cache queue resolved for: ' + key, resolvedData);
-              }
-
-              currentTasks[key][i].res(val);
-            }
-          }
-
-          currentTasks[key] = [];
-          delete currentTasks[key];
-        }
-
-        return val;
-      } catch (e) {
-        if (hOP.call(currentTasks, key)) {
-          for (var i in currentTasks[key]) {
-            if (currentTasks[key][i].rej) {
-              currentTasks[key][i].rej(e);
-            }
-          }
-
-          gorgonCore._callHooks('valueError', { key, asyncFunc, policy, cacheHit: false, queued: false }, e);
-
-          currentTasks[key] = [];
-          delete currentTasks[key];
-        }
-
-        throw e;
-      }
-    },
-  };
-
-  gorgonCore.addProvider('memory', MemoryCache()); // Default provider, light weight and simple
-
-  return gorgonCore;
-})();
-
-export { MemoryCache };
-export default Gorgon;

package/provider/memory.ts

@@ -1,98 +0,0 @@
-import {IGorgonCacheProvider, GorgonPolicySanitized} from '../index';
-
-interface IGorgonMemoryCacheProvider extends IGorgonCacheProvider {
-  _clear: (key:string) => boolean;
-}
-
-// Created as a function to allow for multiple instances of the memory cache, if needed
-const MemoryCacheCreator = ():IGorgonMemoryCacheProvider =>{
-
-  const cache = {};
-  const hOP = cache.hasOwnProperty;
-
-// Memory cache is about the simplist cache possible, use it as an example
-  const memoryCache = {
-
-    init: async() => {
-    // This should be used to update the cache on boot,
-    // memory cache will be blank on boot by default
-      return;
-    },
-
-    get: async(key:string) => {
-
-      if (hOP.call(cache, key) && cache[key].val) {
-      // The cached item exists, return it
-        return cache[key].val;
-      } else {
-      // The cached item does not exist reject
-        return undefined;
-      }
-
-    },
-
-    set: async(key:string, value:any, policy: GorgonPolicySanitized) => {
-
-    // Clear in case it exists
-      await  memoryCache.clear(key);
-
-    // Set a timemout to self-remove from the cache if in policy
-      var to = false as boolean | number;
-
-      if (policy && policy.expiry && policy.expiry > 0) {
-        to = setTimeout(function() {
-          memoryCache.clear(key);
-        }, policy.expiry);
-      }
-
-    // Store the cached item
-      cache[key] = {
-        policy: policy,
-        val: value,
-        to: to,
-      };
-
-      return value;
-
-    },
-
-    keys: async() => {
-      return Object.keys(cache);
-    },
-
-    clear: async(key?:string) => {
-
-    // Clears a single key or complete clear on empty
-    // Clear all items in the cache
-      if (!key) {
-        for (var i in cache) {
-          memoryCache._clear(i);
-        }
-        return true;
-      }
-
-      return memoryCache._clear(key);
-    },
-
-    _clear: (key:string) => {
-    // Clear a single item, making sure to remove the extra timeout
-      if (hOP.call(cache, key)) {
-        if (cache[key].to) {
-          clearTimeout(cache[key].to);
-        }
-
-        cache[key] = null;
-        delete cache[key];
-        return true;
-      }
-
-      return false;
-    },
-
-  };
-
-  return memoryCache;
-
-}
-
-export default MemoryCacheCreator;

package/tsconfig.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "lib": ["es2020", "dom"],
-    "module": "commonjs",
-    "outDir": "dist",
-    "declaration": true,
-    "esModuleInterop": true
-  },
-  "include": ["index.ts", "provider/**/*"]
-}

package/vite.config.js

@@ -1,19 +0,0 @@
-// vite.config.ts
-const path = require('path');
-const {defineConfig} = require('vite');
-const dts = require('vite-plugin-dts');
-
-module.exports = defineConfig({
-  plugins: [dts({insertTypesEntry: true})],
-  build: {
-    sourcemap: true,
-    lib: {
-      type: ['es', 'cjs', 'umd'],
-      entry: path.resolve(__dirname, 'index.ts'),
-      name: 'Gorgon',
-      fileName: format => `index.${format}.js`,
-    },
-    rollupOptions: {
-    },
-  },
-});