@duplojs/utils 1.3.19 → 1.3.20

package/dist/dataParser/parsers/transform.mjs

@@ -6,12 +6,10 @@ import { createOverride } from '../../common/override.mjs';
 const transformKind = createDataParserKind("transform");
 function transform(inner, theFunction, definition) {
     const self = dataParserInit(transformKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            inner,
-            theFunction,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        inner,
+        theFunction,
     }, {
         sync: (data, error, self) => {
             const innerResult = self.definition.inner.exec(data, error);

package/dist/dataParser/parsers/tuple.cjs

@@ -8,12 +8,10 @@ var override = require('../../common/override.cjs');
 const tupleKind = kind.createDataParserKind("tuple");
 function tuple(shape, definition) {
     const self = base.dataParserInit(tupleKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            rest: definition?.rest,
-            shape,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        rest: definition?.rest,
+        shape,
     }, {
         sync: (data, error$1, self) => {
             if (!(data instanceof Array)) {

package/dist/dataParser/parsers/tuple.d.ts

@@ -36,6 +36,7 @@ export interface DataParserTuple<GenericDefinition extends DataParserDefinitionT
         DataParserTupleCheckers<Output<this>>,
         ...DataParserTupleCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTuple<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionTuple>(definition: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, GenericDefinition>>;
 }
 export declare function tuple<GenericShape extends TupleShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTuple<MergeDefinition<DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
     shape: GenericShape;

package/dist/dataParser/parsers/tuple.mjs

@@ -6,12 +6,10 @@ import { createOverride } from '../../common/override.mjs';
 const tupleKind = createDataParserKind("tuple");
 function tuple(shape, definition) {
     const self = dataParserInit(tupleKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            rest: definition?.rest,
-            shape,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        rest: definition?.rest,
+        shape,
     }, {
         sync: (data, error, self) => {
             if (!(data instanceof Array)) {

package/dist/dataParser/parsers/union.cjs

@@ -8,11 +8,9 @@ var override = require('../../common/override.cjs');
 const unionKind = kind.createDataParserKind("union");
 function union(options, definition) {
     const self = base.dataParserInit(unionKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            options,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        options,
     }, {
         sync: (data, error$1, self) => {
             for (const dataParser of self.definition.options) {

package/dist/dataParser/parsers/union.d.ts

@@ -20,6 +20,7 @@ export interface DataParserUnion<GenericDefinition extends DataParserDefinitionU
         DataParserUnionCheckers<Output<this>>,
         ...DataParserUnionCheckers<Output<this>>[]
     ], GenericChecker>): DataParserUnion<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionUnion>(definition: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, GenericDefinition>>;
 }
 export declare function union<GenericOptions extends UnionOptions, const GenericDefinition extends Partial<Omit<DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
     options: GenericOptions;

package/dist/dataParser/parsers/union.mjs

@@ -6,11 +6,9 @@ import { createOverride } from '../../common/override.mjs';
 const unionKind = createDataParserKind("union");
 function union(options, definition) {
     const self = dataParserInit(unionKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-            options,
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        options,
     }, {
         sync: (data, error, self) => {
             for (const dataParser of self.definition.options) {

package/dist/dataParser/parsers/unknown.cjs

@@ -7,10 +7,8 @@ var override = require('../../common/override.cjs');
 const unknownKind = kind.createDataParserKind("unknown");
 function unknown(definition) {
     const self = base.dataParserInit(unknownKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
     }, (data) => data);
     return unknown.overrideHandler.apply(self);
 }

package/dist/dataParser/parsers/unknown.d.ts

@@ -18,6 +18,7 @@ export interface DataParserUnknown<GenericDefinition extends DataParserDefinitio
         DataParserUnknownCheckers,
         ...DataParserUnknownCheckers[]
     ], GenericChecker>): DataParserUnknown<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    construct<const GenericDefinition extends DataParserDefinitionUnknown>(definition: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, GenericDefinition>>;
 }
 export declare function unknown<const GenericDefinition extends Partial<DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace unknown {

package/dist/dataParser/parsers/unknown.mjs

@@ -5,10 +5,8 @@ import { createOverride } from '../../common/override.mjs';
 const unknownKind = createDataParserKind("unknown");
 function unknown(definition) {
     const self = dataParserInit(unknownKind, {
-        definition: {
-            errorMessage: definition?.errorMessage,
-            checkers: definition?.checkers ?? [],
-        },
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
     }, (data) => data);
     return unknown.overrideHandler.apply(self);
 }

package/dist/either/future/create.cjs

@@ -25,9 +25,9 @@ class Future extends Promise {
             .catch((error$1) => error.futureError(error$1))));
     }
     [kind] = null;
-    // @ts-expect-error override signature error
-    then(theFunction) {
-        return new Future(super.then(theFunction));
+    // default declaration
+    then(onfulfilled) {
+        return super.then(onfulfilled);
     }
     static get [Symbol.species]() {
         return Promise;
@@ -37,7 +37,7 @@ class Future extends Promise {
             && value?.constructor?.name === "Future"
             && kind in value;
     }
-    static all(values) {
+    static rightAll(values) {
         return new Future(Promise.all(values.map((value) => new Future(value))));
     }
 }

package/dist/either/future/create.d.ts

@@ -3,12 +3,11 @@ import { type EitherRight } from "../right";
 import { type EitherFutureSuccess } from "./success";
 import { type EitherFutureError } from "./error";
 import { type IsEqual } from "../../common/types/isEqual";
-import { type MaybePromise } from "../../common/types/maybePromise";
 import { type AnyValue } from "../../common";
 type Either = EitherRight | EitherLeft;
 type ComputeEitherFutureSuccessResult<GenericValue extends unknown> = IsEqual<never, Exclude<GenericValue, Either>> extends false ? EitherFutureSuccess<Exclude<GenericValue, Either>> : never;
-type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Promise<unknown> ? EitherFutureError : never;
-type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>;
+type ComputeEitherFutureErrorResult<GenericValue extends unknown> = GenericValue extends Future<any> ? GenericValue : GenericValue extends Promise<unknown> ? EitherFutureError : never;
+type ComputeFutureEitherResult<GenericValue extends unknown = unknown> = (Extract<Awaited<GenericValue>, Either> | ComputeEitherFutureSuccessResult<Awaited<GenericValue>> | ComputeEitherFutureErrorResult<GenericValue>);
 export type FutureEitherAllResult<GenericArray extends readonly unknown[] | []> = Future<{
     -readonly [Prop in keyof GenericArray]: Awaited<Future<GenericArray[Prop]>>;
 }>;
@@ -16,10 +15,10 @@ declare const kind = "kind-future-either";
 export declare class Future<const GenericValue extends unknown = unknown> extends Promise<ComputeFutureEitherResult<GenericValue>> {
     constructor(value: GenericValue);
     [kind]: unknown;
-    then<const GenericOutput extends AnyValue>(theFunction: (result: Extract<ComputeFutureEitherResult<GenericValue>, any>) => MaybePromise<GenericOutput>): Future<GenericOutput>;
+    then<TResult1 = ComputeFutureEitherResult<GenericValue>, TResult2 = never>(onfulfilled?: ((value: ComputeFutureEitherResult<GenericValue>) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult1 | TResult2>;
     static get [Symbol.species](): PromiseConstructor;
     static instanceof<GenericValue extends unknown>(value: GenericValue): value is Extract<GenericValue, Future<any>>;
-    static all<const GenericValue extends unknown, GenericArray extends readonly GenericValue[] | []>(values: GenericArray): FutureEitherAllResult<GenericArray>;
+    static rightAll<const GenericArray extends readonly unknown[]>(values: GenericArray): FutureEitherAllResult<GenericArray>;
 }
 export declare function future<GenericEither extends AnyValue>(value: GenericEither): Future<GenericEither>;
 export {};

package/dist/either/future/create.mjs

@@ -23,9 +23,9 @@ class Future extends Promise {
             .catch((error) => futureError(error))));
     }
     [kind] = null;
-    // @ts-expect-error override signature error
-    then(theFunction) {
-        return new Future(super.then(theFunction));
+    // default declaration
+    then(onfulfilled) {
+        return super.then(onfulfilled);
     }
     static get [Symbol.species]() {
         return Promise;
@@ -35,7 +35,7 @@ class Future extends Promise {
             && value?.constructor?.name === "Future"
             && kind in value;
     }
-    static all(values) {
+    static rightAll(values) {
         return new Future(Promise.all(values.map((value) => new Future(value))));
     }
 }

package/dist/either/index.cjs

@@ -35,6 +35,8 @@ var ok = require('./right/ok.cjs');
 var pipe = require('./right/pipe.cjs');
 var success$1 = require('./right/success.cjs');
 var when$1 = require('./right/when.cjs');
+var group = require('./right/group.cjs');
+var asyncGroup = require('./right/asyncGroup.cjs');
 
 
 
@@ -107,3 +109,5 @@ exports.rightPipe = pipe.rightPipe;
 exports.eitherSuccessKind = success$1.eitherSuccessKind;
 exports.success = success$1.success;
 exports.whenIsRight = when$1.whenIsRight;
+exports.group = group.group;
+exports.asyncGroup = asyncGroup.asyncGroup;

package/dist/either/index.mjs

@@ -33,3 +33,5 @@ export { eitherOkKind, ok } from './right/ok.mjs';
 export { rightPipe } from './right/pipe.mjs';
 export { eitherSuccessKind, success } from './right/success.mjs';
 export { whenIsRight } from './right/when.mjs';
+export { group } from './right/group.mjs';
+export { asyncGroup } from './right/asyncGroup.mjs';

package/dist/either/right/asyncGroup.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var asyncPipe = require('../../common/asyncPipe.cjs');
+var whenNot = require('../../common/whenNot.cjs');
+var asyncReduce = require('../../generator/asyncReduce.cjs');
+var reduce = require('../../generator/reduce.cjs');
+var entries = require('../../object/entries.cjs');
+var success = require('./success.cjs');
+var is = require('../left/is.cjs');
+var when = require('../../common/when.cjs');
+var isType = require('../../common/isType.cjs');
+var when$1 = require('./when.cjs');
+
+function asyncGroup(group) {
+    return asyncPipe.asyncPipe(group, entries.entries, asyncReduce.asyncReduce(reduce.reduceFrom({}), ({ element: [key, value], lastValue, nextWithObject, exit }) => asyncPipe.asyncPipe(value, when.when(isType.isType("function"), (getter) => getter()), when.when(is.isLeft, exit), when$1.whenIsRight((data) => nextWithObject(lastValue, { [key]: data })))), whenNot.whenNot(is.isLeft, success.success));
+}
+
+exports.asyncGroup = asyncGroup;

package/dist/either/right/asyncGroup.d.ts

@@ -0,0 +1,12 @@
+import { type AnyFunction, type SimplifyTopLevel, type MayBeGetter, type Unwrap, type MaybePromise } from "../../common";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "./create";
+import * as DEither from "..";
+type Either = MaybePromise<EitherRight | EitherLeft>;
+type ComputeResult<GenericGroup extends Record<string, MayBeGetter<Either>>> = Promise<DEither.EitherSuccess<SimplifyTopLevel<{
+    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Unwrap<Extract<Awaited<ReturnType<GenericGroup[Prop]>>, EitherRight>> : Unwrap<Extract<Awaited<GenericGroup[Prop]>, EitherRight>>;
+}>> | {
+    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Extract<Awaited<ReturnType<GenericGroup[Prop]>>, EitherLeft> : Extract<Awaited<GenericGroup[Prop]>, EitherLeft>;
+}[keyof GenericGroup]>;
+export declare function asyncGroup<GenericGroup extends Record<string, MayBeGetter<Either>>>(group: GenericGroup): Extract<ComputeResult<GenericGroup>, any>;
+export {};

package/dist/either/right/asyncGroup.mjs

@@ -0,0 +1,16 @@
+import { asyncPipe } from '../../common/asyncPipe.mjs';
+import { whenNot } from '../../common/whenNot.mjs';
+import { asyncReduce } from '../../generator/asyncReduce.mjs';
+import { reduceFrom } from '../../generator/reduce.mjs';
+import { entries } from '../../object/entries.mjs';
+import { success } from './success.mjs';
+import { isLeft } from '../left/is.mjs';
+import { when } from '../../common/when.mjs';
+import { isType } from '../../common/isType.mjs';
+import { whenIsRight } from './when.mjs';
+
+function asyncGroup(group) {
+    return asyncPipe(group, entries, asyncReduce(reduceFrom({}), ({ element: [key, value], lastValue, nextWithObject, exit }) => asyncPipe(value, when(isType("function"), (getter) => getter()), when(isLeft, exit), whenIsRight((data) => nextWithObject(lastValue, { [key]: data })))), whenNot(isLeft, success));
+}
+
+export { asyncGroup };

package/dist/either/right/group.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var pipe = require('../../common/pipe.cjs');
+var whenNot = require('../../common/whenNot.cjs');
+var when = require('../../common/when.cjs');
+var isType = require('../../common/isType.cjs');
+var reduce = require('../../array/reduce.cjs');
+var when$1 = require('./when.cjs');
+var entries = require('../../object/entries.cjs');
+var success = require('./success.cjs');
+var is = require('../left/is.cjs');
+
+function group(group) {
+    return pipe.pipe(group, entries.entries, reduce.reduce(reduce.reduceFrom({}), ({ element: [key, value], lastValue, nextWithObject, exit }) => pipe.pipe(value, when.when(isType.isType("function"), (getter) => getter()), when.when(is.isLeft, exit), when$1.whenIsRight((data) => nextWithObject(lastValue, { [key]: data })))), whenNot.whenNot(is.isLeft, success.success));
+}
+
+exports.group = group;

package/dist/either/right/group.d.ts

@@ -0,0 +1,12 @@
+import { type AnyFunction, type SimplifyTopLevel, type MayBeGetter, type Unwrap } from "../../common";
+import { type EitherLeft } from "../left";
+import { type EitherRight } from "./create";
+import * as DEither from "..";
+type Either = EitherRight | EitherLeft;
+type ComputeResult<GenericGroup extends Record<string, MayBeGetter<Either>>> = (DEither.EitherSuccess<SimplifyTopLevel<{
+    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Unwrap<Extract<ReturnType<GenericGroup[Prop]>, EitherRight>> : Unwrap<Extract<GenericGroup[Prop], EitherRight>>;
+}>> | {
+    [Prop in keyof GenericGroup]: GenericGroup[Prop] extends AnyFunction ? Extract<ReturnType<GenericGroup[Prop]>, EitherLeft> : Extract<GenericGroup[Prop], EitherLeft>;
+}[keyof GenericGroup]);
+export declare function group<GenericGroup extends Record<string, MayBeGetter<Either>>>(group: GenericGroup): Extract<ComputeResult<GenericGroup>, any>;
+export {};

package/dist/either/right/group.mjs

@@ -0,0 +1,15 @@
+import { pipe } from '../../common/pipe.mjs';
+import { whenNot } from '../../common/whenNot.mjs';
+import { when } from '../../common/when.mjs';
+import { isType } from '../../common/isType.mjs';
+import { reduce, reduceFrom } from '../../array/reduce.mjs';
+import { whenIsRight } from './when.mjs';
+import { entries } from '../../object/entries.mjs';
+import { success } from './success.mjs';
+import { isLeft } from '../left/is.mjs';
+
+function group(group) {
+    return pipe(group, entries, reduce(reduceFrom({}), ({ element: [key, value], lastValue, nextWithObject, exit }) => pipe(value, when(isType("function"), (getter) => getter()), when(isLeft, exit), whenIsRight((data) => nextWithObject(lastValue, { [key]: data })))), whenNot(isLeft, success));
+}
+
+export { group };

package/dist/either/right/index.d.ts

@@ -5,3 +5,5 @@ export * from "./ok";
 export * from "./pipe";
 export * from "./success";
 export * from "./when";
+export * from "./group";
+export * from "./asyncGroup";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.3.19",
+  "version": "1.3.20",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",