@orioro/util 0.1.0 → 0.3.0

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,47 @@
+import { PromiseLikeEventEmitter } from '../PromiseLikeEventEmitter';
+type BatchFnOptions = {
+    skip?: (input: any) => Promise<boolean> | boolean;
+    batchSize?: number;
+};
+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(fn: (input: any) => Promise<any> | any, { batchSize, skip }?: 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.1.0",
+  "version": "0.3.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",

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/**',
-}