@orioro/util 0.2.0 → 0.4.0

package/dist/PromiseLikeEventEmitter/index.d.ts

@@ -0,0 +1,10 @@
+import EventEmitter from 'eventemitter3';
+export declare class PromiseLikeEventEmitter<T, EventTypes extends EventEmitter.ValidEventTypes = {}> extends EventEmitter<EventTypes> {
+    private promise;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    constructor();
+    then<TResult = T, TError = any>(onFulfilled?: ((value: T) => TResult | PromiseLike<TResult>) | null, onRejected?: ((reason: any) => TError | PromiseLike<TError>) | null): Promise<TResult | TError>;
+    catch<TError = any>(onRejected?: ((reason: any) => TError | PromiseLike<TError>) | null): Promise<T | TError>;
+    finally(onFinally?: (() => void) | null | undefined): Promise<T>;
+}

package/dist/array/arrayChunk.d.ts

@@ -0,0 +1 @@
+export declare function arrayChunk<T>(array: T[], chunkSize: number): T[][];

package/dist/array/index.d.ts

@@ -0,0 +1 @@
+export * from './arrayChunk';

package/dist/debug/debugFn/index.d.ts

@@ -0,0 +1,15 @@
+import { Merge } from 'type-fest';
+type AnyFn = (...args: any[]) => any;
+export type FnCallLog<FnType extends AnyFn = AnyFn> = {
+    type: 'call';
+    callId: string;
+    fnName: string;
+    args: Parameters<FnType>;
+};
+export type FnResultLog<FnType extends AnyFn = AnyFn> = Merge<FnCallLog<FnType>, {
+    type: 'result';
+    result: ReturnType<FnType>;
+}>;
+export type FnDebugLog<FnType extends AnyFn = AnyFn> = FnCallLog<FnType> | FnResultLog<FnType>;
+export declare function debugFn<FnType extends AnyFn = AnyFn>(fnName: string, fn: FnType, logCall?: (log: FnCallLog<FnType>) => void, logResult?: (log: FnResultLog<FnType>) => void): (...args: Parameters<FnType>) => ReturnType<FnType>;
+export {};

package/dist/debug/debugFn/util.d.ts

@@ -0,0 +1 @@
+export declare function generateDeterministicId(args: any[]): string;

package/dist/debug/debugFn.d.ts

@@ -0,0 +1,15 @@
+import { Merge } from 'type-fest';
+type AnyFn = (...args: any[]) => any;
+export type FnCallLog<FnType extends AnyFn = AnyFn> = {
+    type: 'call';
+    callId: string;
+    fnName: string;
+    args: Parameters<FnType>;
+};
+export type FnResultLog<FnType extends AnyFn = AnyFn> = Merge<FnCallLog<FnType>, {
+    type: 'result';
+    result: ReturnType<FnType>;
+}>;
+export type FnDebugLog<FnType extends AnyFn = AnyFn> = FnCallLog<FnType> | FnResultLog<FnType>;
+export declare function debugFn<FnType extends AnyFn = AnyFn>(fnName: string, fn: FnType, logCall?: (log: FnCallLog<FnType>) => void, logResult?: (log: FnResultLog<FnType>) => void): (...args: Parameters<FnType>) => ReturnType<FnType>;
+export {};

package/dist/debug/deepFreeze.d.ts

@@ -0,0 +1,5 @@
+type AnyObjOrArray = any[] | {
+    [key: string]: any;
+};
+export declare function deepFreeze<T extends AnyObjOrArray = AnyObjOrArray>(object: T): T;
+export {};

package/dist/debug/index.d.ts

@@ -0,0 +1,3 @@
+export * from './wait';
+export * from './deepFreeze';
+export * from './debugFn';

package/dist/debug/wait.d.ts

@@ -0,0 +1 @@
+export declare function wait<ResultType = any>(ms?: number, result?: ResultType | Error): Promise<ResultType>;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './PromiseLikeEventEmitter';
+export * from './debug';
+export * from './interpolate';
+export * from './maybeFn';
+export * from './pickPaths';
+export * from './promise';
+export * from './switchValue';
+export * from './typeOf';
+export * from './validate';

package/dist/index.mjs

@@ -2,6 +2,7 @@ import EventEmitter from 'eventemitter3';
 import copy from 'fast-copy';
 import { getProperty, setProperty } from 'dot-prop';
 import traverse from 'traverse';
+import { backOff } from 'exponential-backoff';
 
 function _typeof(o) {
   "@babel/helpers - typeof";
@@ -379,6 +380,16 @@ function maybeFn(input) {
   return typeof input === 'function' ? input.apply(void 0, args) : input;
 }
 
+function pickPaths(sourceObj, paths) {
+  return paths.reduce(function (acc, path) {
+    var _a = Array.isArray(path) ? path : [path, path],
+      targetPath = _a[0],
+      resolver = _a[1];
+    var value = typeof resolver === 'string' ? getProperty(sourceObj, resolver) : resolver(sourceObj);
+    return setProperty(acc, targetPath, value);
+  }, {});
+}
+
 function promiseReduce(inputArr, reducerFn, initial) {
   return inputArr.reduce(function (prevPromise, input, index) {
     return prevPromise.then(function (acc) {
@@ -467,11 +478,13 @@ function arrayChunk(array, chunkSize) {
 }
 
 var SKIPPED = Symbol();
-function batchFn(fn, _a) {
+function batchFn(itemFn, _a) {
   var _b = _a === void 0 ? {} : _a,
     _c = _b.batchSize,
     batchSize = _c === void 0 ? 10 : _c,
-    skip = _b.skip;
+    skip = _b.skip,
+    _d = _b.retry,
+    retry = _d === void 0 ? false : _d;
   return function batchExec(items) {
     var _this = this;
     var batches = arrayChunk(items, batchSize);
@@ -516,7 +529,11 @@ function batchFn(fn, _a) {
                         _a = SKIPPED;
                         return [3 /*break*/, 4];
                       case 2:
-                        return [4 /*yield*/, fn(item)];
+                        return [4 /*yield*/, retry === true ? backOff(function () {
+                          return itemFn(item);
+                        }) : _typeof(retry) === 'object' && retry !== null ? backOff(function () {
+                          return itemFn(item);
+                        }, retry) : itemFn(item)];
                       case 3:
                         _a = _b.sent();
                         _b.label = 4;
@@ -594,16 +611,6 @@ function parseBatchedResults(inputs, results) {
   });
 }
 
-function resolvePaths(sourceObj, paths) {
-  return paths.reduce(function (acc, path) {
-    var _a = Array.isArray(path) ? path : [path, path],
-      targetPath = _a[0],
-      resolver = _a[1];
-    var value = typeof resolver === 'string' ? getProperty(sourceObj, resolver) : resolver(sourceObj);
-    return setProperty(acc, targetPath, value);
-  }, {});
-}
-
 function testCriteria(criteria, input) {
   switch (_typeof(criteria)) {
     case 'function':
@@ -1472,4 +1479,4 @@ validateAsync.or = or;
 validateAsync.not = not;
 validateAsync.assertValid = assertValidAsync;
 
-export { PromiseLikeEventEmitter, SKIPPED, ValidationError, batchFn, debugFn, deepFreeze, interpolate, makeTypeOf, maybeFn, parseBatchedResults, promiseReduce, resolveNestedPromises, resolvePaths, switchExec, switchValue, typeMap, typeOf, validate, validateAsync, wait };
+export { PromiseLikeEventEmitter, SKIPPED, ValidationError, batchFn, debugFn, deepFreeze, interpolate, makeTypeOf, maybeFn, parseBatchedResults, pickPaths, promiseReduce, resolveNestedPromises, switchExec, switchValue, typeMap, typeOf, validate, validateAsync, wait };

package/dist/interpolate/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @function $stringInterpolate
+ * @param {String} template Basic JS template string like `${value.path}` value
+ *                          interpolation. It is possible to access nested properties
+ *                          through dot `.` notation. Keywords between braces are
+ *                          only interpreted as paths to the value. No logic
+ *                          supported: loops, conditionals, etc.
+ * @param {Object | Array} data Data context to be used for interpolation
+ */
+export declare function interpolate(template: string, data: {
+    [key: string]: any;
+} | any[], { maxLength }?: {
+    maxLength?: number;
+}): string;

package/dist/maybeFn.d.ts

@@ -0,0 +1 @@
+export declare function maybeFn(input: any, ...args: any[]): any;

package/dist/pickPaths/index.d.ts

@@ -0,0 +1,4 @@
+type Resolver = string | ((sourceObj: Record<string, any>) => any);
+type PathSpec = string | [string, Resolver];
+export declare function pickPaths(sourceObj: Record<string, any>, paths: PathSpec[]): Record<string, any>;
+export {};

package/dist/promise/batchFn.d.ts

@@ -0,0 +1,49 @@
+import { PromiseLikeEventEmitter } from '../PromiseLikeEventEmitter';
+import { BackoffOptions } from 'exponential-backoff';
+type BatchFnOptions = {
+    skip?: (input: any) => Promise<boolean> | boolean;
+    batchSize?: number;
+    retry?: BackoffOptions | boolean;
+};
+type Batch = {
+    index: number;
+    items: any[];
+};
+export declare const SKIPPED: unique symbol;
+type EventTypes = {
+    batchStart: (data: {
+        batch: Batch;
+    }) => void;
+    batchProgress: (data: {
+        batch: Batch;
+        progress: number;
+        results: any[];
+    }) => void;
+    itemStart: (data: {
+        batch: Batch;
+        item: any;
+    }) => void;
+    itemSkip: (data: {
+        batch: Batch;
+        item: any;
+    }) => void;
+    progress: (data: {
+        type: 'data' | 'skip' | 'error';
+        batch: Batch;
+        item: any;
+        result: any;
+        progress: number;
+    }) => void;
+    results: (data: {
+        results: any[];
+    }) => void;
+    error: (err: Error) => void;
+};
+export declare function batchFn(itemFn: (input: any) => Promise<any> | any, { batchSize, skip, retry }?: BatchFnOptions): (items: any[]) => PromiseLikeEventEmitter<any[], EventTypes>;
+type ParsedBatchResults = {
+    results: any[];
+    errors: Error[];
+    skipped: any[];
+};
+export declare function parseBatchedResults(inputs: any, results: any[]): ParsedBatchResults;
+export {};

package/dist/promise/index.d.ts

@@ -0,0 +1,3 @@
+export * from './promiseReduce';
+export * from './resolveNestedPromises';
+export * from './batchFn';

package/dist/promise/promiseReduce.d.ts

@@ -0,0 +1 @@
+export declare function promiseReduce<ItemType = any, AccType = any>(inputArr: ItemType[], reducerFn: (acc: AccType, input: ItemType, index: number) => AccType | Promise<AccType>, initial: AccType): Promise<AccType>;

package/dist/promise/resolveNestedPromises.d.ts

@@ -0,0 +1,14 @@
+import { AnyArray, AnyObject } from './types';
+type ResolveCtx = {
+    root: AnyArray | AnyObject;
+    depth: number;
+};
+type ResolveOptions = {
+    mode: 'eager' | 'lazy';
+    maxDepth: number;
+    clone: false | (<T = {
+        [key: string]: any;
+    } | any[]>(obj: T) => T);
+};
+export declare function resolveNestedPromises(node: AnyArray | AnyObject, options?: Partial<ResolveOptions>, ctx?: ResolveCtx): Promise<AnyArray | AnyObject>;
+export {};

package/dist/promise/types.d.ts

@@ -0,0 +1,2 @@
+export type AnyArray = unknown[];
+export type AnyObject = Record<string, unknown>;

package/dist/resolvePaths/index.d.ts

@@ -0,0 +1,4 @@
+type Resolver = string | ((sourceObj: Record<string, any>) => any);
+type PathSpec = string | [string, Resolver];
+export declare function resolvePaths(sourceObj: Record<string, any>, paths: PathSpec[]): Record<string, any>;
+export {};

package/dist/switchValue.d.ts

@@ -0,0 +1,9 @@
+type Criteria = string | symbol | RegExp | ((input: any) => boolean);
+type ObjectSwitchCases<ValueType = any> = {
+    [key: string | symbol]: ValueType;
+};
+type TupleSwitchCases<ValueType = any> = ([Criteria, ValueType] | [ValueType])[];
+export type SwitchCases<ValueType = any> = ObjectSwitchCases<ValueType> | TupleSwitchCases<ValueType>;
+export declare function switchValue<ValueType = any>(input: any, cases: SwitchCases): ValueType | undefined;
+export declare function switchExec<ArgsType extends any[] = any[]>(input: any, cases: SwitchCases<(...args: any[]) => any>, ...args: ArgsType): any;
+export {};

package/dist/typeOf.d.ts

@@ -0,0 +1,7 @@
+export type TypeTest = (value: any) => boolean;
+type TypeMap = Record<string, TypeTest>;
+export declare function typeMap<T extends TypeMap>(typeMap: T): T;
+export declare function makeTypeOf<T extends TypeMap>(typeMap: T): (value: any) => keyof T | null;
+export type DEFAULT_TYPE_NAMES = 'null' | 'undefined' | 'boolean' | 'number' | 'bigint' | 'string' | 'symbol' | 'function' | 'object' | 'array' | 'regexp' | 'nan' | 'date' | 'map' | 'weakmap' | 'set' | 'weakset' | 'promise' | 'error';
+export declare const typeOf: (value: any) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "map" | "error" | "null" | "array" | "regexp" | "nan" | "date" | "weakmap" | "set" | "weakset" | "promise" | null;
+export {};

package/dist/validate/async/index.d.ts

@@ -0,0 +1,18 @@
+import * as common from '../common/validators';
+import * as asyncValidators from './validators';
+import { DetailedInvalid, AsyncValidatorSystem, Valid } from '../types';
+declare function assertValidAsync<InputT = any>(validator: AsyncValidatorSystem['ValidatorInput'], input: InputT): Promise<InputT>;
+interface ValidateAsync {
+    (validatorInput: AsyncValidatorSystem['ValidatorInput'], input: any): Promise<Valid | DetailedInvalid>;
+    type: typeof common.typeValidator;
+    obj: typeof asyncValidators.obj;
+    objOf: typeof asyncValidators.objOf;
+    tuple: typeof asyncValidators.tuple;
+    arrayOf: typeof asyncValidators.arrayOf;
+    and: typeof asyncValidators.and;
+    or: typeof asyncValidators.or;
+    not: typeof asyncValidators.not;
+    assertValid: typeof assertValidAsync;
+}
+export declare const validateAsync: ValidateAsync;
+export {};

package/dist/validate/async/validateAsyncFn.d.ts

@@ -0,0 +1,2 @@
+import { DetailedInvalid, Valid, AsyncValidatorSystem } from '../types';
+export declare function validateAsyncFn(validatorInput: AsyncValidatorSystem['ValidatorInput'], input: any): Promise<Valid | DetailedInvalid>;

package/dist/validate/async/validators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './shape';
+export * from './logical';

package/dist/validate/async/validators/logical.d.ts

@@ -0,0 +1,4 @@
+import { AsyncValidatorSystem } from '../../types';
+export declare function and(validators: AsyncValidatorSystem['ValidatorInput'][]): AsyncValidatorSystem['ValidatorFn'];
+export declare function or(validators: AsyncValidatorSystem['ValidatorInput'][]): AsyncValidatorSystem['ValidatorFn'];
+export declare function not(validator: AsyncValidatorSystem['ValidatorInput']): AsyncValidatorSystem['ValidatorFn'];

package/dist/validate/async/validators/shape.d.ts

@@ -0,0 +1,7 @@
+import { AsyncValidatorSystem } from '../../types';
+export declare function obj(objShape: {
+    [key: string]: AsyncValidatorSystem['ValidatorInput'];
+}): AsyncValidatorSystem['ValidatorFn'];
+export declare function objOf(ofType: AsyncValidatorSystem['ValidatorInput']): AsyncValidatorSystem['ValidatorFn'];
+export declare function tuple(tupleShape: AsyncValidatorSystem['ValidatorInput'][]): AsyncValidatorSystem['ValidatorFn'];
+export declare function arrayOf(ofType: AsyncValidatorSystem['ValidatorInput']): AsyncValidatorSystem['ValidatorFn'];

package/dist/validate/async/validators/tmpand.d.ts

@@ -0,0 +1,2 @@
+import { AsyncValidatorSystem } from '../../types';
+export declare function and(validators: AsyncValidatorSystem['ValidatorInput'][]): AsyncValidatorSystem['ValidatorFn'];

package/dist/validate/async/validators/tmpor.d.ts

@@ -0,0 +1,2 @@
+import { AsyncValidatorSystem } from '../../types';
+export declare function or(validators: AsyncValidatorSystem['ValidatorInput'][]): AsyncValidatorSystem['ValidatorFn'];

package/dist/validate/common/ValidationError.d.ts

@@ -0,0 +1,11 @@
+import { DetailedInvalid } from '../types';
+export declare class ValidationError extends Error {
+    input: any;
+    code?: string;
+    error?: Error;
+    path?: string;
+    nestedErrors?: DetailedInvalid[];
+    name: string;
+    constructor({ message, ...details }: DetailedInvalid);
+    toJSON(): DetailedInvalid;
+}

package/dist/validate/common/util/defaultErrorMessage.d.ts

@@ -0,0 +1,2 @@
+import { DetailedInvalid } from '../../types';
+export declare function defaultErrorMessage({ input, message, nestedErrors, expectedTypes, }: DetailedInvalid): string;

package/dist/validate/common/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './defaultErrorMessage';
+export * from './resolveValidationResult';
+export * from './parseValidatorInput';

package/dist/validate/common/util/parseValidatorInput.d.ts

@@ -0,0 +1,5 @@
+export declare function parseValidatorInput<ValidatorInputT, ValidatorFnT, ValidatorT>({ objValidator, }: {
+    objValidator: (objShape: {
+        [key: string]: ValidatorInputT;
+    }) => ValidatorFnT;
+}, validatorInput: ValidatorInputT): ValidatorT;

package/dist/validate/common/util/resolveValidationResult.d.ts

@@ -0,0 +1,6 @@
+import { DetailedInvalid, Valid, ValidatorErrorMessageFn, ValidatorResult } from '../../types';
+export declare function resolveValidationResult({ input, result, errorMessage, }: {
+    input: any;
+    result: ValidatorResult;
+    errorMessage: ValidatorErrorMessageFn;
+}): Valid | DetailedInvalid;

package/dist/validate/common/validators/index.d.ts

@@ -0,0 +1 @@
+export * from './type';

package/dist/validate/common/validators/type.d.ts

@@ -0,0 +1,9 @@
+import { DEFAULT_TYPE_NAMES } from '../../../typeOf';
+import { CommonValidatorFn } from '../../types';
+type ParsedExpectedType = {
+    type: DEFAULT_TYPE_NAMES;
+    required: boolean;
+};
+type ExpectedTypesInput = (string | ParsedExpectedType)[] | string | ParsedExpectedType;
+export declare function typeValidator(expectedTypesInput: ExpectedTypesInput): CommonValidatorFn;
+export {};

package/dist/validate/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sync';
+export * from './async';
+export * from './common/ValidationError';

package/dist/validate/sync/index.d.ts

@@ -0,0 +1,18 @@
+import * as common from '../common/validators';
+import * as sync from './validators';
+import { DetailedInvalid, SyncValidatorSystem, Valid } from '../types';
+declare function assertValidSync<InputT = any>(validator: SyncValidatorSystem['ValidatorInput'], input: InputT): InputT;
+interface Validate {
+    (validatorInput: SyncValidatorSystem['ValidatorInput'], input: any): Valid | DetailedInvalid;
+    type: typeof common.typeValidator;
+    obj: typeof sync.obj;
+    objOf: typeof sync.objOf;
+    tuple: typeof sync.tuple;
+    arrayOf: typeof sync.arrayOf;
+    and: typeof sync.and;
+    or: typeof sync.or;
+    not: typeof sync.not;
+    assertValid: typeof assertValidSync;
+}
+export declare const validate: Validate;
+export {};

package/dist/validate/sync/validateSyncFn.d.ts

@@ -0,0 +1,2 @@
+import { DetailedInvalid, Valid, SyncValidatorSystem } from '../types';
+export declare function validateSyncFn(validatorInput: SyncValidatorSystem['ValidatorInput'], input: any): Valid | DetailedInvalid;

package/dist/validate/sync/validators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logical';
+export * from './shape';

package/dist/validate/sync/validators/logical.d.ts

@@ -0,0 +1,4 @@
+import { SyncValidatorSystem } from '../../types';
+export declare function and(validators: SyncValidatorSystem['ValidatorInput'][]): SyncValidatorSystem['ValidatorFn'];
+export declare function or(validators: SyncValidatorSystem['ValidatorInput'][]): SyncValidatorSystem['ValidatorFn'];
+export declare function not(validator: SyncValidatorSystem['ValidatorInput']): SyncValidatorSystem['ValidatorFn'];

package/dist/validate/sync/validators/shape.d.ts

@@ -0,0 +1,7 @@
+import { SyncValidatorSystem } from '../../types';
+export declare function obj(objShape: {
+    [key: string]: SyncValidatorSystem['ValidatorInput'];
+}): SyncValidatorSystem['ValidatorFn'];
+export declare function objOf(ofType: SyncValidatorSystem['ValidatorInput']): SyncValidatorSystem['ValidatorFn'];
+export declare function tuple(tupleShape: SyncValidatorSystem['ValidatorInput'][]): SyncValidatorSystem['ValidatorFn'];
+export declare function arrayOf(ofType: SyncValidatorSystem['ValidatorInput']): SyncValidatorSystem['ValidatorFn'];

package/dist/validate/types/async.d.ts

@@ -0,0 +1,5 @@
+import { DetailedInvalid, Valid, ValidatorResult, ValidatorSystem } from './common';
+export type AsyncValidatorSystem = ValidatorSystem<(input: any, context: {
+    validateAsync: AsyncValidateFn;
+}) => ValidatorResult | Promise<ValidatorResult>>;
+export type AsyncValidateFn = (validatorInput: AsyncValidatorSystem['ValidatorInput'], input: any) => Promise<Valid | DetailedInvalid>;

package/dist/validate/types/common.d.ts

@@ -0,0 +1,27 @@
+export type Valid = true;
+export type SimpleInvalid = false | undefined | null;
+export type ErrorMessageInvalid = string;
+export type ErrorInvalid = Error;
+export type DetailedInvalid = {
+    input: any;
+    message?: string;
+    code?: string;
+    error?: Error;
+    path?: string;
+    nestedErrors?: DetailedInvalid[];
+    expectedTypes?: string;
+};
+export type ValidatorResult = Valid | SimpleInvalid | ErrorMessageInvalid | ErrorInvalid | DetailedInvalid;
+export type ValidatorErrorMessageFn = (props: DetailedInvalid) => string;
+export type ValidatorErrorMessageInput = string | ValidatorErrorMessageFn;
+export type CommonValidatorFn = (input: any) => ValidatorResult;
+type _ValidatorFnInput<ValidatorFn> = string | {
+    [key: string]: _ValidatorFnInput<ValidatorFn> | [_ValidatorFnInput<ValidatorFn>, ValidatorErrorMessageInput];
+} | ValidatorFn;
+export type ValidatorSystem<ValidatorFn> = {
+    ValidatorFn: ValidatorFn;
+    ValidatorFnInput: _ValidatorFnInput<ValidatorFn>;
+    Validator: [ValidatorFn, ValidatorErrorMessageFn];
+    ValidatorInput: _ValidatorFnInput<ValidatorFn> | [_ValidatorFnInput<ValidatorFn>, ValidatorErrorMessageInput];
+};
+export {};

package/dist/validate/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './sync';
+export * from './async';

package/dist/validate/types/sync.d.ts

@@ -0,0 +1,5 @@
+import { DetailedInvalid, Valid, ValidatorResult, ValidatorSystem } from './common';
+export type SyncValidatorSystem = ValidatorSystem<(input: any, context: {
+    validateSync: SyncValidateFn;
+}) => ValidatorResult>;
+export type SyncValidateFn = (validatorInput: SyncValidatorSystem['ValidatorInput'], input: any) => Valid | DetailedInvalid;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orioro/util",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "packageManager": "yarn@4.0.2",
   "type": "module",
   "main": "dist/index.mjs",
@@ -9,6 +9,9 @@
     ".": "./dist/index.mjs",
     "./*": "./dist/*"
   },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -17,7 +20,8 @@
     "build:watch": "rollup --config ./rollup.config.mjs --watch",
     "build": "rollup --config ./rollup.config.mjs",
     "test": "jest",
-    "dev": "jest --watch"
+    "dev": "jest --watch",
+    "prepublish": "yarn build"
   },
   "devDependencies": {
     "@orioro/dev": "0.0.0",
@@ -30,6 +34,7 @@
   "dependencies": {
     "dot-prop": "^8.0.2",
     "eventemitter3": "^5.0.1",
+    "exponential-backoff": "^3.1.1",
     "fast-copy": "^3.0.2",
     "traverse": "^0.6.9",
     "type-fest": "^4.18.1"

package/babel.config.cjs

@@ -1,13 +0,0 @@
-//
-// TODO: keep track of babel + jest support for esm and update
-// accordingly
-// https://stackoverflow.com/questions/61146112/error-while-loading-config-you-appear-to-be-using-a-native-ecmascript-module-c
-//
-// import { BABEL_PRESET } from '@orioro/dev/ts'
-
-// export default BABEL_PRESET
-
-module.exports = {
-  presets: ['@babel/preset-env', '@babel/preset-typescript'],
-  exclude: 'node_modules/**',
-}