mirror of
https://github.com/tauri-apps/tauri-forage.git
synced 2026-02-04 02:31:20 +01:00
chore(dist): remove dist
This commit is contained in:
Daniel Thompson-Yvetot
3
.gitignore
vendored
3
.gitignore
vendored
@@ -14,4 +14,5 @@ yarn-error.log*
|
||||
*.sln
|
||||
.c9
|
||||
|
||||
/test/jest/coverage
|
||||
/test/jest/coverage
|
||||
/dist
|
||||
|
||||
2
dist/cryptoForage.js
vendored
2
dist/cryptoForage.js
vendored
File diff suppressed because one or more lines are too long
1
dist/cryptoForage.js.map
vendored
1
dist/cryptoForage.js.map
vendored
File diff suppressed because one or more lines are too long
2
dist/cryptoPrimitives.js
vendored
2
dist/cryptoPrimitives.js
vendored
File diff suppressed because one or more lines are too long
1
dist/cryptoPrimitives.js.map
vendored
1
dist/cryptoPrimitives.js.map
vendored
File diff suppressed because one or more lines are too long
2
dist/curriedForage.js
vendored
2
dist/curriedForage.js
vendored
File diff suppressed because one or more lines are too long
1
dist/curriedForage.js.map
vendored
1
dist/curriedForage.js.map
vendored
File diff suppressed because one or more lines are too long
2
dist/handler.js
vendored
2
dist/handler.js
vendored
@@ -1,2 +0,0 @@
|
||||
!function(e,r){"object"==typeof exports&&"object"==typeof module?module.exports=r():"function"==typeof define&&define.amd?define([],r):"object"==typeof exports?exports.curriedForage=r():e.curriedForage=r()}(global,(function(){return function(e){var r={};function t(n){if(r[n])return r[n].exports;var o=r[n]={i:n,l:!1,exports:{}};return e[n].call(o.exports,o,o.exports,t),o.l=!0,o.exports}return t.m=e,t.c=r,t.d=function(e,r,n){t.o(e,r)||Object.defineProperty(e,r,{enumerable:!0,get:n})},t.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},t.t=function(e,r){if(1&r&&(e=t(e)),8&r)return e;if(4&r&&"object"==typeof e&&e&&e.__esModule)return e;var n=Object.create(null);if(t.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:e}),2&r&&"string"!=typeof e)for(var o in e)t.d(n,o,function(r){return e[r]}.bind(null,o));return n},t.n=function(e){var r=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(r,"a",r),r},t.o=function(e,r){return Object.prototype.hasOwnProperty.call(e,r)},t.p="",t(t.s=0)}([function(e,r,t){var n,o=this&&this.__awaiter||function(e,r,t,n){return new(t||(t=Promise))((function(o,u){function a(e){try{i(n.next(e))}catch(e){u(e)}}function c(e){try{i(n.throw(e))}catch(e){u(e)}}function i(e){var r;e.done?o(e.value):(r=e.value,r instanceof t?r:new t((function(e){e(r)}))).then(a,c)}i((n=n.apply(e,r||[])).next())}))},u=this&&this.__generator||function(e,r){var t,n,o,u,a={label:0,sent:function(){if(1&o[0])throw o[1];return o[1]},trys:[],ops:[]};return u={next:c(0),throw:c(1),return:c(2)},"function"==typeof Symbol&&(u[Symbol.iterator]=function(){return this}),u;function c(u){return function(c){return function(u){if(t)throw new TypeError("Generator is already executing.");for(;a;)try{if(t=1,n&&(o=2&u[0]?n.return:u[0]?n.throw||((o=n.return)&&o.call(n),0):n.next)&&!(o=o.call(n,u[1])).done)return o;switch(n=0,o&&(u=[2&u[0],o.value]),u[0]){case 0:case 1:o=u;break;case 4:return a.label++,{value:u[1],done:!1};case 5:a.label++,n=u[1],u=[0];continue;case 7:u=a.ops.pop(),a.trys.pop();continue;default:if(!(o=(o=a.trys).length>0&&o[o.length-1])&&(6===u[0]||2===u[0])){a=0;continue}if(3===u[0]&&(!o||u[1]>o[0]&&u[1]<o[3])){a.label=u[1];break}if(6===u[0]&&a.label<o[1]){a.label=o[1],o=u;break}if(o&&a.label<o[2]){a.label=o[2],a.ops.push(u);break}o[2]&&a.ops.pop(),a.trys.pop();continue}u=r.call(e,a)}catch(e){u=[6,e],n=0}finally{t=o=0}if(5&u[0])throw u[1];return{value:u[0]?u[1]:void 0,done:!0}}([u,c])}}};void 0===(n=function(e,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.handler={returner:function(e,r){return function(t){r||(r=t);var n=typeof r;if("number"!==n&&"string"!==n)return e;switch(r){case 1:case"quiet":return;case 2:case"console":console.log(e);break;case 3:case"break":throw e instanceof Error?(e.message||(e.message="No value"),e):new Error(e||"No result");case 4:case"truthy":return null!=e&&!1!==e;case 5:case"typeof":if(null===e)return"null";if(void 0===e)return"undefined";if(e instanceof Error)return"error";try{return e.map((function(e){return e})),"array"}catch(r){return typeof e}case 6:case"trace":console.trace("TRACE: "+e);break;case 7:case"passthrough":case"default":default:return e}}},logger:function(e,r){return function(t){if(r||(r=t),"string"==typeof r&&e)switch(r){case"none":return;case"string":return e;case"trace":return void console.trace("TRACE: "+e);case"console":return void console.error(e);case"throw":throw e instanceof Error?(e.message||(e.message="No message"),e):new Error(e||"No result")}}},maybeCurry:function(e){return function(r){return"function"==typeof e?e(r):r}},jsonPurify:function(e){var r,t=void 0===e?{}:e,n=t.model,a=t.maxLen,c={};return function(e){return o(this,void 0,void 0,(function(){return u(this,(function(t){try{return a&&e.length>a?[2,null]:("object"!=typeof(r=JSON.parse(e))||Array.isArray(r)?c=r:n.forEach((function(e){r.hasOwnProperty(e)&&(c[e]=r[e])})),[2,c])}catch(e){return[2,e]}return[2]}))}))}}},r.default={handler:r.handler}}.apply(r,[t,r]))||(e.exports=n)}])}));
|
||||
//# sourceMappingURL=handler.js.map
|
||||
1
dist/handler.js.map
vendored
1
dist/handler.js.map
vendored
File diff suppressed because one or more lines are too long
2
dist/index.js
vendored
2
dist/index.js
vendored
File diff suppressed because one or more lines are too long
1
dist/index.js.map
vendored
1
dist/index.js.map
vendored
File diff suppressed because one or more lines are too long
62
dist/src/cryptoForage.d.ts
vendored
62
dist/src/cryptoForage.d.ts
vendored
@@ -1,62 +0,0 @@
|
||||
import { LoggerType, ReturnerType } from './handler';
|
||||
import { Purifiable } from './types';
|
||||
export interface Enbox {
|
||||
key?: string;
|
||||
loggerType?: LoggerType;
|
||||
returnType?: ReturnerType;
|
||||
}
|
||||
export interface Debox extends Enbox, Purifiable {
|
||||
}
|
||||
/**
|
||||
* @description Use currying process to inject
|
||||
* @namespace
|
||||
* @category forage
|
||||
*/
|
||||
declare const cryptoForage: {
|
||||
/**
|
||||
* @description encrypt a functional
|
||||
* @name enBox
|
||||
* @category forage
|
||||
* @uses forage.mergeItem
|
||||
* @memberof cryptoForage
|
||||
* @param {string} key - encryption key
|
||||
* @param {array} logger - loglevel of errors (forage)
|
||||
* @param {array} returner - return type (forage)
|
||||
* @returns {object|*} - the JSON results of our box
|
||||
* @function
|
||||
* @example
|
||||
* const boxFn = await cryptoForage.enBox({
|
||||
* key:key,
|
||||
* loggerType: 'throw',
|
||||
* returnType: 7
|
||||
* })(new Date().now())
|
||||
*/
|
||||
enBox: ({ key, loggerType, returnType }?: Enbox) => (val: any) => Promise<any>;
|
||||
/**
|
||||
* @name deBox
|
||||
* @description use the "box" system to decrypt something from the storage
|
||||
* @category forage
|
||||
* @memberof cryptoForage
|
||||
* @uses forage.getKeyValue
|
||||
* @param {string} key - encryption key
|
||||
* @param {array} model - array of acceptable properties (validate)
|
||||
* @param {string} maxlen - forage name of key (validate)
|
||||
* @param {string} row - forage row (forage)
|
||||
* @param {string} name - forage name of key (forage)
|
||||
* @param {string} logger - loglevel of errors (forage)
|
||||
* @param {number} returner - return type (forage)
|
||||
* @returns {object|*} - the JSON results of our box
|
||||
* @function
|
||||
* @example
|
||||
* const curry = async function (val) {
|
||||
* const box = await crypto.secretBox.encrypt({
|
||||
* json: val,
|
||||
* key: key
|
||||
* })
|
||||
* console.log(box)
|
||||
* return box
|
||||
* }
|
||||
*/
|
||||
deBox: ({ key, model, maxLen, loggerType, returnType }?: Debox) => (val: Promise<any>) => Promise<any>;
|
||||
};
|
||||
export { cryptoForage };
|
||||
142
dist/src/cryptoPrimitives.d.ts
vendored
142
dist/src/cryptoPrimitives.d.ts
vendored
@@ -1,142 +0,0 @@
|
||||
import { MaybeUint8Array } from './types';
|
||||
export interface Encryptable {
|
||||
json?: object;
|
||||
key?: string;
|
||||
}
|
||||
export interface Decryptable {
|
||||
msg?: string;
|
||||
key?: string;
|
||||
}
|
||||
export interface EncryptableBox {
|
||||
json: object;
|
||||
key: Uint8Array;
|
||||
secretOrSharedKey: Uint8Array;
|
||||
}
|
||||
export interface DecryptableBox {
|
||||
secretOrSharedKey: Uint8Array;
|
||||
messageWithNonce: string;
|
||||
key: Uint8Array;
|
||||
}
|
||||
declare const keyLength: number;
|
||||
/**
|
||||
* @category crypto
|
||||
* @namespace
|
||||
*/
|
||||
declare const crypto: {
|
||||
/**
|
||||
* @name nonce
|
||||
* @category crypto
|
||||
* @memberof crypto
|
||||
* @returns {object}
|
||||
* @function
|
||||
*/
|
||||
nonce(): Uint8Array;
|
||||
/**
|
||||
* @name hash
|
||||
* @category crypto
|
||||
* @memberof crypto
|
||||
* @param {*} input
|
||||
* @returns {string}
|
||||
* @function
|
||||
*/
|
||||
hash(input: string): string;
|
||||
/**
|
||||
* @name secretBox
|
||||
* @category crypto
|
||||
* @description Make a public key / private key box
|
||||
* @namespace
|
||||
* @memberof crypto
|
||||
* @example
|
||||
* ```
|
||||
* const key = generateKey()
|
||||
* const obj = { "hello": "world" }
|
||||
* const encrypted = crypto.nacl.secretBox.encrypt(obj, key)
|
||||
* const decrypted = crypto.nacl.secretBox.decrypt(encrypted, key)
|
||||
* console.log(decrypted, obj) // should be shallow equal
|
||||
* ```
|
||||
*/
|
||||
secretBox: {
|
||||
/**
|
||||
* @name keyGen
|
||||
* @category crypto
|
||||
* @memberof crypto.secretBox
|
||||
* @param {*} input
|
||||
* @function
|
||||
*/
|
||||
keyGen(input: MaybeUint8Array): string;
|
||||
/**
|
||||
* @name encrypt
|
||||
* @category crypto
|
||||
* @memberof crypto.secretBox
|
||||
* @param {object} json
|
||||
* @param {string} key
|
||||
* @throws {Error}
|
||||
* @returns {string}
|
||||
* @function
|
||||
*/
|
||||
encrypt: ({ json, key }?: Encryptable) => Promise<string>;
|
||||
/**
|
||||
* @name decrypt
|
||||
* @category crypto
|
||||
* @memberof crypto.secretBox
|
||||
* @param {string} msg
|
||||
* @param {string} key
|
||||
* @throws {error} - Could not decrypt message
|
||||
* @returns {object}
|
||||
* @function
|
||||
*/
|
||||
decrypt: ({ msg, key }?: Decryptable) => Promise<any>;
|
||||
};
|
||||
/**
|
||||
* @name box
|
||||
* @category crypto
|
||||
* @namespace
|
||||
* @memberof crypto
|
||||
* @description Make a public key / private key box
|
||||
* @example
|
||||
* ```
|
||||
* const obj = { hello: 'world' };
|
||||
* const pairA = crypto.nacl.box.generateKeyPair();
|
||||
* const pairB = gcrypto.nacl.box.enerateKeyPair();
|
||||
* const sharedA = box.before(pairB.publicKey, pairA.secretKey);
|
||||
* const sharedB = box.before(pairA.publicKey, pairB.secretKey);
|
||||
* const encrypted = crypto.nacl.box.encrypt(sharedA, obj);
|
||||
* const decrypted = crypto.nacl.box.decrypt(sharedB, encrypted);
|
||||
* console.log(obj, encrypted, decrypted);
|
||||
* ```
|
||||
*
|
||||
*/
|
||||
box: {
|
||||
/**
|
||||
* @name generateKeyPair
|
||||
* @category crypto
|
||||
* @memberof crypto.box
|
||||
* @returns {object}
|
||||
* @function
|
||||
*/
|
||||
generateKeyPair(): import("tweetnacl").BoxKeyPair;
|
||||
/**
|
||||
* @name box.encrypt
|
||||
* @category crypto
|
||||
* @memberof crypto.box
|
||||
* @param {string} secretOrSharedKey
|
||||
* @param {object} json
|
||||
* @param {string} key
|
||||
* @function
|
||||
*/
|
||||
encrypt({ secretOrSharedKey, json, key }: EncryptableBox): string;
|
||||
/**
|
||||
* @name decrypt
|
||||
* @category crypto
|
||||
* @memberof crypto.box
|
||||
* @param {string} secretOrSharedKey
|
||||
* @param {string} messageWithNonce
|
||||
* @param {string} key
|
||||
* @throws {error}
|
||||
* @returns {string}
|
||||
* @function
|
||||
*/
|
||||
decrypt({ secretOrSharedKey, messageWithNonce, key }: DecryptableBox): any;
|
||||
};
|
||||
};
|
||||
export { crypto, keyLength };
|
||||
251
dist/src/curriedForage.d.ts
vendored
251
dist/src/curriedForage.d.ts
vendored
@@ -1,251 +0,0 @@
|
||||
import { LoggerType, ReturnerType, MaybeLoggerType } from './handler';
|
||||
import { MaybeFunction } from './types';
|
||||
export declare type Store = {};
|
||||
export interface Item {
|
||||
key?: string;
|
||||
logger?: LoggerType;
|
||||
returner?: ReturnerType;
|
||||
store?: string;
|
||||
}
|
||||
export interface BeforeItem extends Item {
|
||||
before?: boolean;
|
||||
}
|
||||
export interface IndexItem extends BeforeItem {
|
||||
index?: number;
|
||||
}
|
||||
export interface KeyValueItem extends BeforeItem {
|
||||
value?: string;
|
||||
}
|
||||
export interface MergeItem extends KeyValueItem {
|
||||
type?: string;
|
||||
}
|
||||
/**
|
||||
* @description -> externally, we are using the same API as localForage,
|
||||
* with the exception of the dropInstance interface, which, while
|
||||
* still available, has been split out into three distinct calls.
|
||||
* Also, are using `.then` instead of the callback approach, and
|
||||
* always catch an error.
|
||||
*
|
||||
* Of note are the extensions to the generic interface:
|
||||
* - mergeItem (with a number of merge strategies available)
|
||||
* - getKeyValue
|
||||
* - deleteItemKey
|
||||
* - hasKey
|
||||
* - hasKeyValue
|
||||
*
|
||||
* Note:
|
||||
* Even if undefined is saved, null will be returned by getItem().
|
||||
* This is due to a limitation in localStorage, and for compatibility
|
||||
* reasons localForage cannot store the value undefined.
|
||||
*
|
||||
* The process is:
|
||||
* 1. forage.config({object})
|
||||
* 2. forage.ready()
|
||||
* 3. forage.set('user', { age: 12 })
|
||||
* 4. forage.get('user')
|
||||
* 5. forage.clear()
|
||||
*
|
||||
* Usage Options:
|
||||
* 1. Exactly the same interface as localForage
|
||||
* 2. With a currying function applied to the result
|
||||
* 3. Modify the value returned (with or without curry)
|
||||
* 4. Define error suppression
|
||||
*
|
||||
* @category forage
|
||||
* @namespace forage
|
||||
*/
|
||||
declare const forage: {
|
||||
/**
|
||||
* @description get the object of a specific row if it exists.
|
||||
* @
|
||||
* @param {string} key
|
||||
* @param {string} logger
|
||||
* @param {number} returner
|
||||
* @returns {Promise<object|string|*>}
|
||||
* @function getItem
|
||||
* @memberof forage
|
||||
*/
|
||||
getItem({ key, logger, returner, before, store }?: BeforeItem): (curry?: MaybeFunction) => Promise<any>;
|
||||
/**
|
||||
* @description get the value of a specific key in a row if it exists.
|
||||
*
|
||||
* @param {string} key
|
||||
* @param {string} value
|
||||
* @param {function} curry
|
||||
* @param {string} logger
|
||||
* @param {number|string} returner
|
||||
* @returns {Promise<object|string|*>}
|
||||
* @function getKeyValue
|
||||
* @memberof forage
|
||||
*/
|
||||
getKeyValue({ key, value, logger, returner, before, store }?: KeyValueItem): (curry?: MaybeFunction) => Promise<any>;
|
||||
/**
|
||||
* @description set an row if it exists, completely overwrite it if
|
||||
* it does not exist.
|
||||
*
|
||||
* @param {string} key
|
||||
* @param {string} value
|
||||
* @param {...Function|string|number} restArgs
|
||||
* @param {function} restArgs.curry
|
||||
* @param {string} restArgs.logger
|
||||
* @param {number} restArgs.returner
|
||||
* @returns {Promise<object|string|*>}
|
||||
* @function setItem
|
||||
* @memberof forage
|
||||
*/
|
||||
setItem({ key, value, logger, returner, before, store }?: KeyValueItem): (curry?: MaybeFunction) => Promise<any>;
|
||||
/**
|
||||
*
|
||||
* @param {...Function|string|number} restArgs
|
||||
* @param {number} restArgs.index
|
||||
* @param {function} restArgs.curry
|
||||
* @param {string} restArgs.logger
|
||||
* @param {number} restArgs.returner
|
||||
* @returns {Promise<string>}
|
||||
* @function setItem
|
||||
* @memberof forage
|
||||
*/
|
||||
key({ index, logger, returner, before, store }?: IndexItem): (curry: MaybeFunction) => Promise<any>;
|
||||
/**
|
||||
* @description Merging data shouldn't be hard, so that logic is in here.
|
||||
* There are so many ways to do it though, that the caller can define
|
||||
* merge strategy. This is a "prebuilt" Curry.
|
||||
*
|
||||
* See https://ramdajs.com/docs/ for the exact features we are using.
|
||||
*
|
||||
* The default is to use the `deepWithKey` approach.
|
||||
*
|
||||
* @param {string} key
|
||||
* @param {string|object|array} value
|
||||
* @param {string} type
|
||||
* @param {...Function|string|number} restArgs
|
||||
* @param {function} restArgs.curry
|
||||
* @param {string} restArgs.logger
|
||||
* @param {number} restArgs.returner
|
||||
* @returns {Promise<object|string|*>}
|
||||
* @function mergeItem
|
||||
* @memberof forage
|
||||
*/
|
||||
mergeItem({ key, value, type, returner, logger, before, store }?: MergeItem): (curry?: MaybeFunction) => Promise<any>;
|
||||
removeItem({ key, logger, returner, before, store }?: BeforeItem): (curry?: MaybeFunction) => Promise<any>;
|
||||
deleteItemKey: (key: string, value: string | string[], ...restArgs: any[]) => Promise<any>;
|
||||
clear({ logger, store }?: {
|
||||
logger?: MaybeLoggerType;
|
||||
store?: string;
|
||||
}): (curry?: MaybeFunction) => Promise<any>;
|
||||
length({ logger, returner, store }?: {
|
||||
logger?: LoggerType;
|
||||
returner?: ReturnerType;
|
||||
store?: string;
|
||||
}): (curry?: MaybeFunction) => Promise<any>;
|
||||
/**
|
||||
* EXPERIMENTAL!!!
|
||||
* @param {number} index
|
||||
* @returns {Promise<string>}
|
||||
*/
|
||||
keys({ logger, returner, store }?: {
|
||||
logger?: LoggerType;
|
||||
returner?: ReturnerType;
|
||||
store?: any;
|
||||
}): (curry: MaybeFunction) => Promise<any>;
|
||||
hasKey({ key, logger, returner, store }?: Item): (curry?: MaybeFunction) => Promise<any>;
|
||||
hasKeyValue({ key, value, logger, returner }?: {
|
||||
key?: string;
|
||||
value?: string;
|
||||
logger?: LoggerType;
|
||||
returner?: ReturnerType;
|
||||
}): (curry?: MaybeFunction) => Promise<any>;
|
||||
iterate<T, U>(iteratorCallback: (value: T, key: string, iterationNumber: number) => U, callback: (err: any, result: U) => void): void;
|
||||
/**
|
||||
*
|
||||
* @param {object} options
|
||||
*/
|
||||
config(options: any): boolean;
|
||||
/**
|
||||
* not async, not thenable
|
||||
* don't use this. prefer to use config
|
||||
* @returns {string}
|
||||
*/
|
||||
driver(): string;
|
||||
ready: () => Promise<boolean>;
|
||||
/**
|
||||
* This will return the entire object.
|
||||
* If you just want to know if it worked, do this:
|
||||
* ```
|
||||
* const driver = !!forage.createInstance({ name: 'Test' })
|
||||
* ```
|
||||
* @param {string} name
|
||||
* @returns {boolean}
|
||||
*/
|
||||
createInstance({ name, logger }?: {
|
||||
name?: string;
|
||||
logger?: any;
|
||||
}): LocalForage;
|
||||
dropInstance: ({ name }: {
|
||||
name: string;
|
||||
}) => Promise<boolean>;
|
||||
dropAll: () => Promise<boolean>;
|
||||
dropStore({ name, storeName }: {
|
||||
name: string;
|
||||
storeName: string;
|
||||
}): Promise<void>;
|
||||
};
|
||||
declare const internals: {
|
||||
_mapArgs: (arr: any[]) => ({
|
||||
curry: any;
|
||||
logger?: undefined;
|
||||
returner?: undefined;
|
||||
before?: undefined;
|
||||
} | {
|
||||
logger: any;
|
||||
curry?: undefined;
|
||||
returner?: undefined;
|
||||
before?: undefined;
|
||||
} | {
|
||||
returner: any;
|
||||
curry?: undefined;
|
||||
logger?: undefined;
|
||||
before?: undefined;
|
||||
} | {
|
||||
before: any;
|
||||
curry?: undefined;
|
||||
logger?: undefined;
|
||||
returner?: undefined;
|
||||
})[];
|
||||
_defineStore: ({ store }?: {
|
||||
store?: string;
|
||||
}) => LocalForage;
|
||||
};
|
||||
declare const getItem: ({ key, logger, returner, before, store }?: BeforeItem) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const getKeyValue: ({ key, value, logger, returner, before, store }?: KeyValueItem) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const setItem: ({ key, value, logger, returner, before, store }?: KeyValueItem) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const key: ({ index, logger, returner, before, store }?: IndexItem) => (curry: MaybeFunction) => Promise<any>;
|
||||
declare const mergeItem: ({ key, value, type, returner, logger, before, store }?: MergeItem) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const removeItem: ({ key, logger, returner, before, store }?: BeforeItem) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const deleteItemKey: ({ key, logger, returner, before, store }?: BeforeItem) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const clear: ({ logger, store }?: {
|
||||
logger?: MaybeLoggerType;
|
||||
store?: string;
|
||||
}) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const length: ({ logger, returner, store }?: {
|
||||
logger?: LoggerType;
|
||||
returner?: ReturnerType;
|
||||
store?: string;
|
||||
}) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const keys: ({ logger, returner, store }?: {
|
||||
logger?: LoggerType;
|
||||
returner?: ReturnerType;
|
||||
store?: any;
|
||||
}) => (curry: MaybeFunction) => Promise<any>;
|
||||
declare const hasKey: ({ key, logger, returner, store }?: Item) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const hasKeyValue: ({ key, value, logger, returner }?: {
|
||||
key?: string;
|
||||
value?: string;
|
||||
logger?: LoggerType;
|
||||
returner?: ReturnerType;
|
||||
}) => (curry?: MaybeFunction) => Promise<any>;
|
||||
declare const ready: () => Promise<boolean>;
|
||||
declare const defineStore: ({ store }?: {
|
||||
store?: string;
|
||||
}) => LocalForage;
|
||||
export { forage, getItem, getKeyValue, setItem, key, mergeItem, removeItem, deleteItemKey, clear, length, keys, hasKey, hasKeyValue, ready, defineStore, internals };
|
||||
142
dist/src/handler.d.ts
vendored
142
dist/src/handler.d.ts
vendored
@@ -1,142 +0,0 @@
|
||||
import { MaybeFunction, Empty, Purifiable } from './types';
|
||||
export declare type ReturnerType = string | number | object;
|
||||
export declare type MaybeReturnerType = ReturnerType | Empty;
|
||||
export declare type LoggerType = 'none' | 'string' | 'trace' | 'console' | 'throw';
|
||||
export declare type MaybeLoggerType = LoggerType | Empty;
|
||||
/**
|
||||
* @namespace handler
|
||||
* @category handler
|
||||
*/
|
||||
export declare const handler: {
|
||||
/**
|
||||
* @name returner
|
||||
* @description Return the value - or don't.
|
||||
* Of special note is case 4, which will tell you if the
|
||||
* result of the operation is true, false, null or undefined.
|
||||
* You can use numbers or strings
|
||||
*
|
||||
* ## TYPES
|
||||
* - 1(quiet) - return void 0
|
||||
* - 2(console) - log the returned value to the console
|
||||
* - 3(break) - throw an error with the contents of the return
|
||||
* - 4(truthy) - return a true or false value
|
||||
* - 5(typeof) - return type of response
|
||||
* - 6(trace) - get a console.trace() of the call stack
|
||||
* - 7(passthrough) - the default does nothing to the return
|
||||
*
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {*} val
|
||||
* @param {MaybeReturnerType} type
|
||||
* @throws {Error} the message it is passed (if type 3)
|
||||
* @returns {*}
|
||||
* @function
|
||||
*/
|
||||
returner(val: any, type: MaybeReturnerType): (returnerType?: ReturnerType) => any;
|
||||
/**
|
||||
* @function logger
|
||||
* @description Set logging type for returning errors in a number of ways.
|
||||
* @examples
|
||||
* handler.returner('not ava')() // returns 'not ava'
|
||||
* handler.returner('not ava')('truthy') // returns true
|
||||
* handler.returner('not ava', 'truthy')() // returns true
|
||||
*
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {*} msg
|
||||
* @param {MaybeLoggerType} type
|
||||
* @throws {Error} - just the message it is passed
|
||||
* @returns {*}
|
||||
*/
|
||||
logger(msg: any, type: MaybeLoggerType): (loggerType?: LoggerType) => any;
|
||||
/**
|
||||
* @name maybeCurry
|
||||
* @description If a function is passed, apply it to the value.
|
||||
* Otherwise, just return the value.
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {function} fn
|
||||
* @param {*} val
|
||||
* @returns {*}
|
||||
* @function
|
||||
*/
|
||||
maybeCurry(fn: MaybeFunction): (val: any) => any;
|
||||
/**
|
||||
* @name jsonPurify
|
||||
* @description accepts an array and tries to parse the object passed
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {object} model - the model to map against
|
||||
* @param {number} maxLen - max length of model
|
||||
* @function
|
||||
*/
|
||||
jsonPurify({ model, maxLen }?: Purifiable): (str: string) => Promise<any>;
|
||||
};
|
||||
declare const _default: {
|
||||
handler: {
|
||||
/**
|
||||
* @name returner
|
||||
* @description Return the value - or don't.
|
||||
* Of special note is case 4, which will tell you if the
|
||||
* result of the operation is true, false, null or undefined.
|
||||
* You can use numbers or strings
|
||||
*
|
||||
* ## TYPES
|
||||
* - 1(quiet) - return void 0
|
||||
* - 2(console) - log the returned value to the console
|
||||
* - 3(break) - throw an error with the contents of the return
|
||||
* - 4(truthy) - return a true or false value
|
||||
* - 5(typeof) - return type of response
|
||||
* - 6(trace) - get a console.trace() of the call stack
|
||||
* - 7(passthrough) - the default does nothing to the return
|
||||
*
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {*} val
|
||||
* @param {MaybeReturnerType} type
|
||||
* @throws {Error} the message it is passed (if type 3)
|
||||
* @returns {*}
|
||||
* @function
|
||||
*/
|
||||
returner(val: any, type: MaybeReturnerType): (returnerType?: ReturnerType) => any;
|
||||
/**
|
||||
* @function logger
|
||||
* @description Set logging type for returning errors in a number of ways.
|
||||
* @examples
|
||||
* handler.returner('not ava')() // returns 'not ava'
|
||||
* handler.returner('not ava')('truthy') // returns true
|
||||
* handler.returner('not ava', 'truthy')() // returns true
|
||||
*
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {*} msg
|
||||
* @param {MaybeLoggerType} type
|
||||
* @throws {Error} - just the message it is passed
|
||||
* @returns {*}
|
||||
*/
|
||||
logger(msg: any, type: MaybeLoggerType): (loggerType?: LoggerType) => any;
|
||||
/**
|
||||
* @name maybeCurry
|
||||
* @description If a function is passed, apply it to the value.
|
||||
* Otherwise, just return the value.
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {function} fn
|
||||
* @param {*} val
|
||||
* @returns {*}
|
||||
* @function
|
||||
*/
|
||||
maybeCurry(fn: MaybeFunction): (val: any) => any;
|
||||
/**
|
||||
* @name jsonPurify
|
||||
* @description accepts an array and tries to parse the object passed
|
||||
* @category handler
|
||||
* @memberof handler
|
||||
* @param {object} model - the model to map against
|
||||
* @param {number} maxLen - max length of model
|
||||
* @function
|
||||
*/
|
||||
jsonPurify({ model, maxLen }?: Purifiable): (str: string) => Promise<any>;
|
||||
};
|
||||
};
|
||||
export default _default;
|
||||
5
dist/src/index.d.ts
vendored
5
dist/src/index.d.ts
vendored
@@ -1,5 +0,0 @@
|
||||
import { cryptoForage } from './cryptoForage';
|
||||
import { forage } from './curriedForage';
|
||||
import { crypto } from './cryptoPrimitives';
|
||||
import { handler } from './handler';
|
||||
export { forage, cryptoForage, handler, crypto };
|
||||
7
dist/src/types.d.ts
vendored
7
dist/src/types.d.ts
vendored
@@ -1,7 +0,0 @@
|
||||
export declare type Empty = null | void;
|
||||
export declare type MaybeFunction = (val: any) => any | Empty;
|
||||
export declare type MaybeUint8Array = Uint8Array | Empty;
|
||||
export interface Purifiable {
|
||||
model?: any[];
|
||||
maxLen?: number;
|
||||
}
|
||||
Reference in New Issue
Block a user