@buley/dash 0.0.30

package/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: lEBGXHtQZ1qbYV4G5MRkyqwDEZmWStEg8

package/.github/workflows/opencommit.yml

@@ -0,0 +1,33 @@
+# https://github.com/di-sukharev/opencommit
+name: 'Commit Reshaping'
+
+on:
+  push:
+    branches-ignore: [main dev development release]
+
+jobs:
+  opencommit:
+    timeout-minutes: 5
+    name: Commit Reshaping (OpenCommit)
+    runs-on: ubuntu-latest
+    permissions: write-all
+    steps:
+      - name: Setup Node.js Environment
+        uses: actions/setup-node@v2
+        with:
+          node-version: '16'
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - uses: di-sukharev/opencommit@github-action-v1.0.4
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        env:
+          OCO_OPENAI_MAX_TOKENS: 500
+          OCO_OPENAI_API_KEY: ${{ secrets.OCO_OPENAI_API_KEY }}
+          OCO_OPENAI_BASE_PATH: ''
+          OCO_DESCRIPTION: false
+          OCO_EMOJI: true
+          OCO_MODEL: gpt-4
+          OCO_LANGUAGE: en
+          OCO_MESSAGE_TEMPLATE_PLACEHOLDER: '$msg'

package/.github/workflows/testing.yml

@@ -0,0 +1,20 @@
+name: Unit Testing
+
+on: [pull_request]
+
+jobs:
+  unit-test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20.x]
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: Install dependencies
+      run: npm install
+    - name: Run Unit Tests
+      run: npm run test:unit

package/README.md

@@ -0,0 +1,98 @@
+# Dash
+
+Dash is a simple, lightweight wrapper around the IndexedDB API. It provides a promise-based interface for working with IndexedDB, making it easier to perform database operations in web applications.
+
+## Features
+
+- Promise-based API for IndexedDB operations
+- Modular design with separate modules for databases, stores, indexes, and entries
+- Built-in error handling and type safety with TypeScript
+- Support for custom behaviors and extensions
+- Lightweight and easy to integrate into existing projects
+
+## Installation
+
+```bash
+npm install @buley/dash
+```
+
+## Usage
+
+Here's a basic example of how to use Dash:
+
+```javascript
+import dash from '@buley/dash';
+
+// Open a database
+dash.database.open({ database: 'myDB', version: 1 })
+  .then(ctx => {
+    // Create an object store
+    return dash.stores.add({
+      ...ctx,
+      store: 'myStore',
+      store_key_path: 'id',
+      auto_increment: true
+    });
+  })
+  .then(ctx => {
+    // Add an entry to the store
+    return dash.entry.add({
+      ...ctx,
+      data: { name: 'John Doe', age: 30 }
+    });
+  })
+  .then(ctx => {
+    console.log('Entry added successfully:', ctx.entry);
+  })
+  .catch(error => {
+    console.error('An error occurred:', error);
+  });
+```
+
+## API Reference
+
+Dash provides methods for working with databases, stores, indexes, and entries. Here are some of the key modules:
+
+- `dash.database`: Methods for working with databases (open, close, delete)
+- `dash.stores`: Methods for working with object stores (add, remove, get)
+- `dash.indexes`: Methods for working with indexes (add, remove, get)
+- `dash.entry`: Methods for working with individual entries (add, get, put, remove, update, count)
+
+Each module provides methods that return promises, allowing for easy chaining of operations.
+
+## Behaviors
+
+Dash supports custom behaviors that can be added to modify or extend its functionality. Behaviors can be used to implement logging, validation, or any custom logic you need.
+
+```javascript
+dash.behaviors.add((ctx) => {
+  console.log('Operation:', ctx.type, ctx.method);
+  return ctx;
+});
+```
+
+### Testing
+
+To run unit tests:
+
+```
+npm run test
+```
+
+[![Coverage Status](https://coveralls.io/repos/github/buley/dash/badge.svg?branch=master)](https://coveralls.io/github/buley/dash?branch=master)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+This project is licensed under the MIT License.
+
+## Author
+
+[Taylor Buley](https://buley.info) (@taylorbuley)
+
+---
+
+Version: 0.0.30

package/behaviors/cache.dev.js

@@ -0,0 +1,282 @@
+var dashCache = (function (environment) {
+  "use strict";
+  var that,
+    cache = {},
+    set = function( request ) { 
+        var key = request.key || null
+            , value = request.value || null
+            , expires = request.expires || 3000 //in millisecons
+            , current_date = new Date()
+            , timestamp = ( current_date.getTime() + expires );
+        if( 'undefined' === typeof key || null === key ) {
+            return;
+        }
+        cache = cache || {};
+        cache[ key ] = {
+            data: value,
+            expire: timestamp
+        };
+        return cache[ key ].data;
+    },
+    get = function( request ) {
+        cache = cache || {};
+        var key = request.key || '';
+        if( 'undefined' === typeof key || null === key ) {
+            return null;
+        }
+        if(cache[ key ]) {
+            if(cache[ key ].expire > new Date().getTime()) {
+                cache[ key ].data = cache[ key ].data || {};
+                return cache[ key ].data;
+            }
+            delete cache[key];
+        }
+        return null;
+    },
+    zap = function( request ) {
+        cache = cache || {};
+        var key = request.key || ''
+          , temp
+          , keys = key.split('.')
+          , result;
+        if( 'undefined' === typeof key || null === key ) {
+            return;
+        }
+        result = cache[ key ];
+        delete cache[ key ];
+        return result;
+    },
+    buildKey = function(key_ctx, type) {
+        var key = [ key_ctx.database, key_ctx.store, key_ctx.index, key_ctx.key, key_ctx.primary_key, key_ctx.limit ].reduce(function(acc, current){
+            acc = acc || [];
+            if(!!current) {
+                acc = [ acc, current ].join('.');
+            }
+            return acc;
+        });
+        return key;
+    },
+    scripts = ( !! environment.document) ? environment.document.getElementsByTagName("script") : [],
+    libraryScript = scripts[scripts.length - 1] || null,
+    libraryPath =( null !== libraryScript && null !== libraryScript.src.match(/cache/) && null === libraryScript.src.match(/chrome-extension/) ) ? libraryScript.src : self.currentScript || null,
+    workerEnvironment = null !== environment.constructor.toString().match(/WorkerGlobalScope/),
+    worker = !!workerEnvironment && !!libraryPath && null !== libraryPath.match(/cache/) && undefined !== Worker ? new Worker(libraryPath) : null,
+    workQueue = {},
+    workRegister = function (worker, message, context, success, error, notify) {
+      var id = that.random(),
+        callback = function (e) {
+          var data = e.data,
+            queued = workQueue[data.uid];
+          if (undefined !== queued) {
+            switch (e.data.type) {
+            case 'success':
+              delete workQueue[data.uid];
+              worker.removeEventListener('message', callback);
+              that.apply(success, [data.context]);
+              break;
+            case 'error':
+              delete workQueue[data.uid];
+              worker.removeEventListener('message', callback);
+              that.apply(error, [data.context]);
+              break;
+            case 'abort':
+              that.apply(notify, [data.context]);
+              break;
+            default:
+              break;
+            }
+          }
+        },
+        clean = function(obj) {
+          if (that.isFunction(obj)) { 
+            return undefined;
+          } else if (that.isObject(obj)) {
+            that.iterate(obj, function(key, val) {
+              obj[ key ] = clean(val);
+            });
+          } else if (that.isArray(obj)) {
+            that.each(obj, function(v, i) {
+              obj[i] = clean(v);
+            });
+          }
+          return obj;          
+        };
+      workQueue[id] = {
+        success: success,
+        error: error,
+        notify: notify
+      };
+      if ( !!worker ) {
+          worker.addEventListener('message', callback);
+          worker.postMessage({
+            method: message,
+            context: clean(context),
+            uid: id
+          });
+      } else {
+        throw new Error('non-Worker interface not yet implemented');
+      }
+      return id;
+    },
+    workDispatch = function (message, context) {
+      var defd = that.deferred(),
+        callbacks = {
+          on_success: context.on_success,
+          on_error: context.on_error,
+          on_abort: context.on_abort,
+          on_complete: context.on_complete,
+          on_upgrade_needed: context.on_upgrade_needed,
+          on_blocked: context.on_blocked,
+          on_close: context.on_close
+        },
+        getData = function (data) {
+          if( that.isObject(data) )  {
+              that.iterate(callbacks, function (key, val) {
+                data[key] = val;
+              });
+          }
+          return data;
+        };
+      that.iterate(callbacks, function (key, val) {
+        delete context[key];
+      });
+      workRegister(worker, message, context, function (data) {
+        defd.resolve(getData(data));
+      }, function (data) {
+        defd.reject(getData(data));
+      }, function (data) {
+        defd.notify(getData(data));
+      });
+      return defd.promise;
+    };
+
+  if (true === workerEnvironment) {
+    environment.addEventListener('message', function (e) {
+      var input = e.data,
+        method = input.method,
+        value = input.value,
+        key = input.key,
+        context = input.context,
+        expires = input.expires,
+        prune = function(obj) {
+            var isReducible = function(input) {
+                var attrs = 0,
+                    attr;
+                if ( undefined === input || null === input || 'string' === typeof input || 'number' === typeof input || 'function' === typeof input.slice ) {
+                    return false;
+                }
+                for ( attr in input ) {
+                    if ( true === input.hasOwnProperty(attr) ) {
+                        attrs += 1;
+                    }
+                }
+                return ( attrs >= 1 ) ? true : false;
+            }, reduce = function(input) {
+                var attrs = {},
+                    attr;
+                for ( attr in input ) {
+                    if ( true === input.hasOwnProperty(attr) ) {
+                        if ( !!input[ attr ] && !!input[ attr ].expire && ( input[ attr ].expire < new Date().getTime() ) ) {
+                          //skip
+                        } else if ( isReducible(input[ attr ] ) ) {
+                            attrs[ attr ] = reduce(input[ attr ]);
+                        } else {
+                            attrs[ attr ] = input[ attr ];
+                        }
+                    }
+                }
+                return attrs
+            };
+            return reduce(obj);
+        },
+        end = function (ctx) {
+          input.context = ctx;
+          input.type = 'success';
+          environment.postMessage(input);
+          setTimeout(function() {
+            cache = prune(cache);
+          });
+        };
+      if (method === 'get' || method === 'set' || method === 'delete') {
+        if ( method === 'get' ) {
+            end(get(context));
+        } else if ( method === 'set' ) {
+            end(set(context));
+        } else if ( method === 'delete' ) {
+            end(zap(context));
+        }
+      } else {
+        input.type = 'error';
+        end({
+          type: 'abort',
+          context: input,
+          error: 'No such method'
+        });
+      }
+    }, false);
+  } else {
+      return [ function (state) {
+        that = this;
+        if(this.isEmpty(state.context.cache)) {
+          return state;
+        }
+        var promise = state.promise,
+            outward = this.deferred(),
+            inward,
+            response,
+            callbacks = {
+                on_success: state.context.on_success,
+                on_error: state.context.on_error,
+                on_abort: state.context.on_abort,
+                on_complete: state.context.on_complete,
+                on_upgrade_needed: state.context.on_upgrade_needed,
+                on_blocked: state.context.on_blocked,
+                on_close: state.context.on_close
+              }
+        if (this.contains(['get.entry'], state.method)) {
+            inward = workDispatch('get', { key: buildKey(state.context) } );
+            inward(function(response) {
+                if(that.isEmpty(response)) {
+                    state.context.cached = false;
+                } else {
+                    state = response;
+                    state.promise = outward.promise;
+                    state.context.cached = true;
+                    that.iterate(callbacks, function(key, val) {
+                        if (!that.isEmpty(val)) {
+                            state.context[key] = val;
+                        }
+                    });
+                    state.type = 'resolve';
+                    outward.resolve(state);
+                }
+            });
+        }
+        return state;
+      }, function (state) {
+        if(this.is(state.context.cached, true) || this.is(state.context.cache, false)) {
+          return state;
+        }
+        var promise = state.promise,
+            outward = this.deferred(),
+            inward,
+            response,
+            args;
+        if (this.contains(['resolve','error'], state.type)) {
+            state.promise = outward.promise;
+          args = { key: buildKey(state.context, state.type) } ;
+          if ( !this.isEmpty(state.context.purge) || this.contains(['remove.entry', 'remove.entries', 'remove.index', 'remove.store', 'remove.database' ], state.method) ) {
+            inward = workDispatch('zap', args );
+          } else {
+            args.expires = state.context.expires || 3000;
+            args.value = state;
+            inward = workDispatch('set', args );
+          }
+          inward(function(ctx2){
+            outward.resolve(ctx2);
+          });
+        }
+        return state;
+      } ];
+    }
+}(self));