@duplojs/utils 1.3.21 → 1.3.22

package/dist/dataParser/parsers/object/omit.d.ts

@@ -1,6 +1,7 @@
 import { type MergeDefinition } from "../../../dataParser/types";
-import { type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
 import { type SimplifyTopLevel, type NeverCoalescing } from "../../../common";
+export declare function omitShape(shape: DataParserObjectShape, omitObject: Partial<Record<string, true>>): DataParserObjectShape;
 export declare function omit<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: SimplifyTopLevel<Omit<GenericDataParserObject["definition"]["shape"], keyof GenericOmitObject>>;
 }>>;

package/dist/dataParser/parsers/object/omit.mjs

@@ -5,9 +5,12 @@ import { isKeyof } from '../../../string/isKeyof.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
+function omitShape(shape, omitObject) {
+    return pipe(shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
+}
 function omit(dataParser, omitObject, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, filter(([key]) => !isKeyof(key, omitObject)), fromEntries);
+    const newShape = omitShape(dataParser.definition.shape, omitObject);
     return object(newShape, definition);
 }
 
-export { omit };
+export { omit, omitShape };

package/dist/dataParser/parsers/object/partial.cjs

@@ -12,9 +12,13 @@ var entry = require('../../../object/entry.cjs');
 var entries = require('../../../object/entries.cjs');
 var fromEntries = require('../../../object/fromEntries.cjs');
 
+function partialShape(shape) {
+    return pipe.pipe(shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight(forward.forward), when$1.whenIsLeft(optional.optional), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+}
 function partial(dataParser, definition) {
-    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight(forward.forward), when$1.whenIsLeft(optional.optional), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+    const newShape = partialShape(dataParser.definition.shape);
     return index.object(newShape, definition);
 }
 
 exports.partial = partial;
+exports.partialShape = partialShape;

package/dist/dataParser/parsers/object/partial.d.ts

@@ -9,6 +9,7 @@ export type PartialDataParserObject<GenericShape extends DataParserObjectShape>
         coalescingValue: unknown;
     }>;
 }>;
+export declare function partialShape(shape: DataParserObjectShape): DataParserObjectShape;
 export declare function partial<GenericDataParserObject extends DataParserObject, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: PartialDataParserObject<GenericDataParserObject["definition"]["shape"]>;
 }>>;

package/dist/dataParser/parsers/object/partial.mjs

@@ -10,9 +10,12 @@ import { entry } from '../../../object/entry.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
+function partialShape(shape) {
+    return pipe(shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight(forward), whenIsLeft(optional), (dataParser) => entry(key, dataParser))), fromEntries);
+}
 function partial(dataParser, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight(forward), whenIsLeft(optional), (dataParser) => entry(key, dataParser))), fromEntries);
+    const newShape = partialShape(dataParser.definition.shape);
     return object(newShape, definition);
 }
 
-export { partial };
+export { partial, partialShape };

package/dist/dataParser/parsers/object/pick.cjs

@@ -7,9 +7,13 @@ var isKeyof = require('../../../string/isKeyof.cjs');
 var entries = require('../../../object/entries.cjs');
 var fromEntries = require('../../../object/fromEntries.cjs');
 
-function pick(dataParser, omitObject, definition) {
-    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, omitObject)), fromEntries.fromEntries);
+function pickShape(shape, pickObject) {
+    return pipe.pipe(shape, entries.entries, filter.filter(([key]) => isKeyof.isKeyof(key, pickObject)), fromEntries.fromEntries);
+}
+function pick(dataParser, pickObject, definition) {
+    const newShape = pickShape(dataParser.definition.shape, pickObject);
     return index.object(newShape, definition);
 }
 
 exports.pick = pick;
+exports.pickShape = pickShape;

package/dist/dataParser/parsers/object/pick.d.ts

@@ -1,6 +1,7 @@
 import { type MergeDefinition } from "../../../dataParser/types";
-import { type DataParserDefinitionObject, type DataParserObject } from ".";
+import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
 import { type SimplifyTopLevel, type NeverCoalescing, type Adaptor } from "../../../common";
-export declare function pick<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, omitObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
+export declare function pickShape(shape: DataParserObjectShape, pickObject: Partial<Record<string, true>>): DataParserObjectShape;
+export declare function pick<GenericDataParserObject extends DataParserObject, const GenericOmitObject extends Partial<Record<keyof GenericDataParserObject["definition"]["shape"], true>>, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, pickObject: GenericOmitObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: SimplifyTopLevel<Pick<GenericDataParserObject["definition"]["shape"], Adaptor<keyof GenericOmitObject, keyof GenericDataParserObject["definition"]["shape"]>>>;
 }>>;

package/dist/dataParser/parsers/object/pick.mjs

@@ -5,9 +5,12 @@ import { isKeyof } from '../../../string/isKeyof.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
-function pick(dataParser, omitObject, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, filter(([key]) => isKeyof(key, omitObject)), fromEntries);
+function pickShape(shape, pickObject) {
+    return pipe(shape, entries, filter(([key]) => isKeyof(key, pickObject)), fromEntries);
+}
+function pick(dataParser, pickObject, definition) {
+    const newShape = pickShape(dataParser.definition.shape, pickObject);
     return object(newShape, definition);
 }
 
-export { pick };
+export { pick, pickShape };

package/dist/dataParser/parsers/object/required.cjs

@@ -12,9 +12,13 @@ var entry = require('../../../object/entry.cjs');
 var entries = require('../../../object/entries.cjs');
 var fromEntries = require('../../../object/fromEntries.cjs');
 
+function requiredShape(shape) {
+    return pipe.pipe(shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight((dataParser) => dataParser.definition.inner), when$1.whenIsLeft(forward.forward), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+}
 function required(dataParser, definition) {
-    const newShape = pipe.pipe(dataParser.definition.shape, entries.entries, map.map(([key, dataParser]) => pipe.pipe(identifier.identifier(dataParser, optional.optionalKind), when.whenIsRight((dataParser) => dataParser.definition.inner), when$1.whenIsLeft(forward.forward), (dataParser) => entry.entry(key, dataParser))), fromEntries.fromEntries);
+    const newShape = requiredShape(dataParser.definition.shape);
     return index.object(newShape, definition);
 }
 
 exports.required = required;
+exports.requiredShape = requiredShape;

package/dist/dataParser/parsers/object/required.d.ts

@@ -5,6 +5,7 @@ import { type DataParserOptional } from "../optional";
 export type RequireDataParserObject<GenericShape extends DataParserObjectShape> = SimplifyTopLevel<{
     [Prop in keyof GenericShape]: GenericShape[Prop] extends DataParserOptional<any> ? GenericShape[Prop]["definition"]["inner"] : GenericShape[Prop];
 }>;
+export declare function requiredShape(shape: DataParserObjectShape): DataParserObjectShape;
 export declare function required<GenericDataParserObject extends DataParserObject, const GenericDefinition extends Partial<Omit<DataParserDefinitionObject, "shape" | "optimizedShape">> = never>(dataParser: GenericDataParserObject, definition?: GenericDefinition): DataParserObject<MergeDefinition<DataParserDefinitionObject, NeverCoalescing<GenericDefinition, {}> & {
     readonly shape: RequireDataParserObject<GenericDataParserObject["definition"]["shape"]>;
 }>>;

package/dist/dataParser/parsers/object/required.mjs

@@ -10,9 +10,12 @@ import { entry } from '../../../object/entry.mjs';
 import { entries } from '../../../object/entries.mjs';
 import { fromEntries } from '../../../object/fromEntries.mjs';
 
+function requiredShape(shape) {
+    return pipe(shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight((dataParser) => dataParser.definition.inner), whenIsLeft(forward), (dataParser) => entry(key, dataParser))), fromEntries);
+}
 function required(dataParser, definition) {
-    const newShape = pipe(dataParser.definition.shape, entries, map(([key, dataParser]) => pipe(identifier(dataParser, optionalKind), whenIsRight((dataParser) => dataParser.definition.inner), whenIsLeft(forward), (dataParser) => entry(key, dataParser))), fromEntries);
+    const newShape = requiredShape(dataParser.definition.shape);
     return object(newShape, definition);
 }
 
-export { required };
+export { required, requiredShape };

package/dist/dataParser/parsers/refine.cjs

@@ -4,7 +4,7 @@ var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
-const dataParserCheckerRefineKind = kind.createDataParserKind("checker-string-max");
+const dataParserCheckerRefineKind = kind.createDataParserKind("refine");
 function checkerRefine(theFunction, definition) {
     return base.dataParserCheckerInit(dataParserCheckerRefineKind, {
         definition: {

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

@@ -4,7 +4,7 @@ import { type AssignObjects } from "../../object";
 export interface DataParserCheckerDefinitionRefine extends DataParserCheckerDefinition {
     theFunction(input: unknown): boolean;
 }
-export declare const dataParserCheckerRefineKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/checker-string-max", unknown>>;
+export declare const dataParserCheckerRefineKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/refine", unknown>>;
 type _DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine> = (Kind<typeof dataParserCheckerRefineKind.definition> & DataParserChecker<GenericDefinition, string>);
 export interface DataParserCheckerRefine<GenericDefinition extends DataParserCheckerDefinitionRefine = DataParserCheckerDefinitionRefine> extends _DataParserCheckerRefine<GenericDefinition> {
 }

package/dist/dataParser/parsers/refine.mjs

@@ -2,7 +2,7 @@ import { dataParserCheckerInit } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
-const dataParserCheckerRefineKind = createDataParserKind("checker-string-max");
+const dataParserCheckerRefineKind = createDataParserKind("refine");
 function checkerRefine(theFunction, definition) {
     return dataParserCheckerInit(dataParserCheckerRefineKind, {
         definition: {

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

@@ -15,7 +15,7 @@ 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<TResult1 = ComputeFutureEitherResult<GenericValue>, TResult2 = never>(onfulfilled?: ((value: ComputeFutureEitherResult<GenericValue>) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult1 | TResult2>;
+    then<TResult1 = Extract<ComputeFutureEitherResult<GenericValue>, any>, TResult2 = never>(onfulfilled?: ((value: Extract<ComputeFutureEitherResult<GenericValue>, any>) => 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 rightAll<const GenericArray extends readonly unknown[]>(values: GenericArray): FutureEitherAllResult<GenericArray>;

package/dist/index.cjs

@@ -26,7 +26,7 @@ var simpleClone = require('./common/simpleClone.cjs');
 var sleep = require('./common/sleep.cjs');
 var stringToBytes = require('./common/stringToBytes.cjs');
 var stringToMillisecond = require('./common/stringToMillisecond.cjs');
-var toJson = require('./common/toJson.cjs');
+var toJSON = require('./common/toJSON.cjs');
 var toTransform = require('./common/toTransform.cjs');
 var toWrappedValue = require('./common/toWrappedValue.cjs');
 var unwrap = require('./common/unwrap.cjs');
@@ -101,7 +101,7 @@ exports.InvalidBytesInStringError = stringToBytes.InvalidBytesInStringError;
 exports.stringToBytes = stringToBytes.stringToBytes;
 exports.InvalidMillisecondInStringError = stringToMillisecond.InvalidMillisecondInStringError;
 exports.stringToMillisecond = stringToMillisecond.stringToMillisecond;
-exports.toJSON = toJson.toJSON;
+exports.toJSON = toJSON.toJSON;
 exports.toTransform = toTransform.toTransform;
 exports.toWrappedValue = toWrappedValue.toWrappedValue;
 exports.unwrap = unwrap.unwrap;

package/dist/index.mjs

@@ -48,7 +48,7 @@ export { simpleClone } from './common/simpleClone.mjs';
 export { sleep } from './common/sleep.mjs';
 export { InvalidBytesInStringError, stringToBytes } from './common/stringToBytes.mjs';
 export { InvalidMillisecondInStringError, stringToMillisecond } from './common/stringToMillisecond.mjs';
-export { toJSON } from './common/toJson.mjs';
+export { toJSON } from './common/toJSON.mjs';
 export { toTransform } from './common/toTransform.mjs';
 export { toWrappedValue } from './common/toWrappedValue.mjs';
 export { unwrap } from './common/unwrap.mjs';