@duplojs/utils 1.4.32 → 1.4.34

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

@@ -2,6 +2,41 @@ import { type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserObjectShape, type DataParserDefinitionObject, type DataParserObject } from ".";
 import { type SimplifyTopLevel, type NeverCoalescing, type Adaptor } from "../../../common";
 export declare function pickShape(shape: DataParserObjectShape, pickObject: Partial<Record<string, true>>): DataParserObjectShape;
+/**
+ * Creates a new object parser by selecting a subset of keys.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.pick(objectParser, pickObject, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Builds a new object parser using only the selected keys from the original shape.
+ * 
+ * ```ts
+ * const userParser = DP.object({
+ * 	id: DP.number(),
+ * 	name: DP.string(),
+ * 	email: DP.string(),
+ * });
+ * 
+ * const picked = DP.pick(userParser, {
+ * 	id: true,
+ * 	name: true,
+ * });
+ * const result = picked.parse({
+ * 	id: 1,
+ * 	name: "Alex",
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: { id: number; name: string }
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DP
+ * 
+ */
 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

@@ -8,6 +8,9 @@ import { fromEntries } from '../../../object/fromEntries.mjs';
 function pickShape(shape, pickObject) {
     return pipe(shape, entries, filter(([key]) => isKeyof(key, pickObject)), fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/pick/index.md}
+ */
 function pick(dataParser, pickObject, definition) {
     const newShape = pickShape(dataParser.definition.shape, pickObject);
     return object(newShape, definition);

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

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

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

@@ -6,6 +6,43 @@ export type RequireDataParserObject<GenericShape extends DataParserObjectShape>
     [Prop in keyof GenericShape]: GenericShape[Prop] extends DataParserOptional<any> ? GenericShape[Prop]["definition"]["inner"] : GenericShape[Prop];
 }>;
 export declare function requiredShape(shape: DataParserObjectShape): DataParserObjectShape;
+/**
+ * Creates a new object parser where optional properties become required.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.required(objectParser, definition?)` -> returns an object parser
+ * - Curried: not available
+ * 
+ * Unwraps optional properties in the object shape so all keys are required.
+ * 
+ * ```ts
+ * const userParser = DP.object({
+ * 	id: DP.number(),
+ * 	name: DP.string(),
+ * });
+ * 
+ * const partialUser = DP.partial(userParser);
+ * const requiredUser = DP.required(partialUser);
+ * const result = requiredUser.parse({
+ * 	id: 1,
+ * 	name: "Alex",
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: { id: number; name: string }
+ * }
+ * 
+ * const fromOptional = DP.required(DP.object({
+ * 	name: DP.optional(DP.string()),
+ * }));
+ * const requiredResult = fromOptional.parse({ name: "Alex" });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/object
+ * 
+ * @namespace DP
+ * 
+ */
 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

@@ -13,6 +13,9 @@ import { fromEntries } from '../../../object/fromEntries.mjs';
 function requiredShape(shape) {
     return pipe(shape, entries, map(([key, dataParser]) => pipe(dataParser, when(identifier(optionalKind), (dataParser) => dataParser.definition.inner), whenIsLeft(forward), (dataParser) => entry(key, dataParser))), fromEntries);
 }
+/**
+ * {@include dataParser/classic/object/required/index.md}
+ */
 function required(dataParser, definition) {
     const newShape = requiredShape(dataParser.definition.shape);
     return object(newShape, definition);

package/dist/dataParser/parsers/optional.cjs

@@ -5,6 +5,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const optionalKind = kind.createDataParserKind("optional");
+/**
+ * {@include dataParser/classic/optional/index.md}
+ */
 function optional(inner, definition) {
     const self = base.dataParserInit(optionalKind, {
         errorMessage: definition?.errorMessage,

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

@@ -20,11 +20,37 @@ export interface DataParserOptional<GenericDefinition extends DataParserDefiniti
         DataParserOptionalCheckers<Output<this>>,
         ...DataParserOptionalCheckers<Output<this>>[]
     ], GenericChecker>): DataParserOptional<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionOptional>(definition: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that accepts undefined or the inner parser output.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.optional(inner, definition?)` -> returns an optional parser
+ * - Curried: not available
+ * 
+ * Returns undefined (or a coalescing value) when input is undefined, otherwise parses with the inner parser.
+ * 
+ * ```ts
+ * const parser = DP.optional(DP.string());
+ * const result = parser.parse(undefined);
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string | undefined
+ * }
+ * 
+ * const withCoalescing = DP.optional(DP.number(), { coalescingValue: 0 });
+ * const coalesced = withCoalescing.parse(undefined);
+ * 
+ * const withCheckers = DP.optional(DP.number(), {
+ * 	checkers: [DP.checkerRefine((value) => value !== 13)],
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/optional
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function optional<GenericDataParser extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionOptional<Output<GenericDataParser> | undefined>, "inner">> = never>(inner: GenericDataParser, definition?: GenericDefinition): DataParserOptional<MergeDefinition<DataParserDefinitionOptional, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
 }>>;

package/dist/dataParser/parsers/optional.mjs

@@ -3,6 +3,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const optionalKind = createDataParserKind("optional");
+/**
+ * {@include dataParser/classic/optional/index.md}
+ */
 function optional(inner, definition) {
     const self = dataParserInit(optionalKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/pipe.cjs

@@ -5,6 +5,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const pipeKind = kind.createDataParserKind("pipe");
+/**
+ * {@include dataParser/classic/pipe/index.md}
+ */
 function pipe(input, output, definition) {
     const self = base.dataParserInit(pipeKind, {
         errorMessage: definition?.errorMessage,

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

@@ -20,11 +20,38 @@ export interface DataParserPipe<GenericDefinition extends DataParserDefinitionPi
         DataParserPipeCheckers<Output<this>>,
         ...DataParserPipeCheckers<Output<this>>[]
     ], GenericChecker>): DataParserPipe<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionPipe>(definition: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, GenericDefinition>>;
 }
+/**
+ * Creates a data parser pipeline from an input parser to an output parser.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.pipe(input, output, definition?)` -> returns a pipe parser
+ * - Curried: not available
+ * 
+ * Runs the input parser, then feeds its output to the output parser.
+ * 
+ * ```ts
+ * const schema = DP.pipe(
+ * 	DP.coerce.number(),
+ * 	DP.transform(
+ * 		DP.number(),
+ * 		(value) => value + 1,
+ * 	),
+ * );
+ * 
+ * const result = schema.parse("1234");
+ * 
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/pipe
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function pipe<GenericInput extends DataParser, GenericOutput extends DataParser, const GenericDefinition extends Partial<Omit<DataParserDefinitionPipe, "input" | "output">> = never>(input: GenericInput, output: GenericOutput, definition?: GenericDefinition): DataParserPipe<MergeDefinition<DataParserDefinitionPipe, NeverCoalescing<GenericDefinition, {}> & {
     input: GenericInput;
     output: GenericOutput;

package/dist/dataParser/parsers/pipe.mjs

@@ -3,6 +3,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const pipeKind = createDataParserKind("pipe");
+/**
+ * {@include dataParser/classic/pipe/index.md}
+ */
 function pipe(input, output, definition) {
     const self = dataParserInit(pipeKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/record/index.cjs

@@ -7,6 +7,9 @@ var findRecordRequiredKey = require('./findRecordRequiredKey.cjs');
 var override = require('../../../common/override.cjs');
 
 const recordKind = kind.createDataParserKind("record");
+/**
+ * {@include dataParser/classic/record/index.md}
+ */
 function record(key, value, definition) {
     const self = base.dataParserInit(recordKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/record/index.d.ts

@@ -35,11 +35,44 @@ export interface DataParserRecord<GenericDefinition extends DataParserDefinition
         DataParserRecordCheckers<Output<this>>,
         ...DataParserRecordCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecord<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionRecord>(definition: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for records with key and value parsers.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.record(key, value, definition?)` -> returns a record parser
+ * - Curried: not available
+ * 
+ * Validates that the input is an object and parses each key and value with the provided parsers.
+ * 
+ * ```ts
+ * const parser = DP.record(DP.string(), DP.number());
+ * const result = parser.parse({
+ * 	aKey: 1,
+ * 	bKey: 2,
+ * });
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: Record<string, number>
+ * }
+ * 
+ * const keyUnion = DP.union([DP.literal("xPos"), DP.literal("yPos")]);
+ * const strictKeys = DP.record(keyUnion, DP.boolean());
+ * const strictResult = strictKeys.parse({
+ * 	xPos: true,
+ * 	yPos: false,
+ * });
+ * 
+ * const withCheckers = DP.record(DP.string(), DP.string(), {
+ * 	checkers: [DP.checkerRefine((value) => Object.keys(value).length > 0)],
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/record
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function record<GenericDataParserKey extends DataParserRecordKey, GenericDataParserValue extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionRecord> = never>(key: GenericDataParserKey, value: GenericDataParserValue, definition?: GenericDefinition): DataParserRecord<MergeDefinition<DataParserDefinitionRecord, NeverCoalescing<GenericDefinition, {}> & {
     key: GenericDataParserKey;
     value: GenericDataParserValue;

package/dist/dataParser/parsers/record/index.mjs

@@ -6,6 +6,9 @@ export { findRecordRequiredKeyOnTemplateLiteralPart } from './findRecordRequired
 import { createOverride } from '../../../common/override.mjs';
 
 const recordKind = createDataParserKind("record");
+/**
+ * {@include dataParser/classic/record/index.md}
+ */
 function record(key, value, definition) {
     const self = dataParserInit(recordKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/recover.cjs

@@ -5,6 +5,9 @@ var kind = require('../kind.cjs');
 var override = require('../../common/override.cjs');
 
 const recoverKind = kind.createDataParserKind("recover");
+/**
+ * {@include dataParser/classic/recover/index.md}
+ */
 function recover(inner, recoveredValue, definition) {
     const self = base.dataParserInit(recoverKind, {
         errorMessage: definition?.errorMessage,

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

@@ -20,11 +20,37 @@ export interface DataParserRecover<GenericDefinition extends DataParserDefinitio
         DataParserRecoverCheckers<Output<this>>,
         ...DataParserRecoverCheckers<Output<this>>[]
     ], GenericChecker>): DataParserRecover<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionRecover>(definition: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, GenericDefinition>>;
 }
+/**
+ * Creates a data parser that recovers with a fallback value on error.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.recover(inner, recoveredValue, definition?)` -> returns a recover parser
+ * - Curried: not available
+ * 
+ * Runs the inner parser and returns the recovered value when parsing fails.
+ * 
+ * ```ts
+ * const parser = DP.recover(DP.number(), 0);
+ * const result = parser.parse("not-a-number");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: number
+ * }
+ * 
+ * const withString = DP.recover(DP.string(), "fallback");
+ * const stringResult = withString.parse(123);
+ * 
+ * const withCheckers = DP.recover(DP.string(), "fallback", {
+ * 	checkers: [DP.checkerRefine((value) => value.length > 0)],
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/recover
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function recover<GenericDataParser extends DataParser, GenericRecoveredValue extends Output<GenericDataParser>, const GenericDefinition extends Partial<Omit<DataParserDefinitionRecover, "inner" | "recoveredValue">> = never>(inner: GenericDataParser, recoveredValue: GenericRecoveredValue, definition?: GenericDefinition): DataParserRecover<MergeDefinition<DataParserDefinitionRecover, NeverCoalescing<GenericDefinition, {}> & {
     inner: GenericDataParser;
     recoveredValue: GenericRecoveredValue;

package/dist/dataParser/parsers/recover.mjs

@@ -3,6 +3,9 @@ import { createDataParserKind } from '../kind.mjs';
 import { createOverride } from '../../common/override.mjs';
 
 const recoverKind = createDataParserKind("recover");
+/**
+ * {@include dataParser/classic/recover/index.md}
+ */
 function recover(inner, recoveredValue, definition) {
     const self = dataParserInit(recoverKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/string/index.cjs

@@ -6,6 +6,9 @@ var kind = require('../../kind.cjs');
 var override = require('../../../common/override.cjs');
 
 const stringKind = kind.createDataParserKind("string");
+/**
+ * {@include dataParser/classic/string/index.md}
+ */
 function string(definition) {
     const self = base.dataParserInit(stringKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/string/index.d.ts

@@ -21,11 +21,37 @@ export interface DataParserString<GenericDefinition extends DataParserDefinition
         DataParserStringCheckers,
         ...DataParserStringCheckers[]
     ], GenericChecker>): DataParserString<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionString>(definition: GenericDefinition): DataParserString<MergeDefinition<DataParserDefinitionString, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for strings.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.string(definition?)` -> returns a string parser
+ * - Curried: not available
+ * 
+ * Validates that the input is a string, optionally applies coerce, and runs the configured checkers.
+ * 
+ * ```ts
+ * const parser = DP.string();
+ * const result = parser.parse("DuploJS");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * const withCheckers = DP.string({
+ * 	checkers: [DP.checkerStringMin(3), DP.checkerStringMax(10)],
+ * });
+ * 
+ * const coerceParser = DP.coerce.string();
+ * const coerceResult = coerceParser.parse(123);
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/string
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function string<const GenericDefinition extends Partial<DataParserDefinitionString> = never>(definition?: GenericDefinition): DataParserString<MergeDefinition<DataParserDefinitionString, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace string {
     var overrideHandler: import("../../../common").OverrideHandler<DataParserString<DataParserDefinitionString>>;

package/dist/dataParser/parsers/string/index.mjs

@@ -4,6 +4,9 @@ import { createDataParserKind } from '../../kind.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const stringKind = createDataParserKind("string");
+/**
+ * {@include dataParser/classic/string/index.md}
+ */
 function string(definition) {
     const self = dataParserInit(stringKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.cjs

@@ -41,9 +41,9 @@ function createTemplateLiteralPattern(templatePart) {
         int: innerPipe.innerPipe(find.find(int.checkerIntKind.has), when$1.when(int.checkerIntKind.has, justReturn.justReturn(true))),
     }), ({ int }) => {
         if (int) {
-            return "(?:[0-9]+)";
+            return "(?:-?[0-9]+)";
         }
-        return "(?:[0-9]+(\\.[0-9]+)?)";
+        return "(?:-?[0-9]+(?:\\.[0-9]+)?)";
     })), when.when(index$2.bigIntKind.has, () => "(?:[0-9]+n)"), when.when(boolean.booleanKind.has, () => "(?:true|false)"), when.when(nil.nilKind.has, () => "(?:null)"), when.when(empty.emptyKind.has, () => "(?:undefined)"), when.when(literal.literalKind.has, (dataParser) => pipe.pipe(dataParser.definition.value, map.map((element) => createTemplateLiteralPattern([element])), join.join("|"), (pattern) => `(?:${pattern})`)), when.when(index$1.stringKind.has, (dataParser) => pipe.pipe(dataParser.definition.checkers, to.to({
         email: innerPipe.innerPipe(find.find(email.checkerEmailKind.has), when$1.when(email.checkerEmailKind.has, (checker) => pipe.pipe(checker.definition.pattern.source, replace.replace(/^\^/, ""), replace.replace(/\$$/, "")))),
         min: innerPipe.innerPipe(find.find(min.checkerStringMinKind.has), when$1.when(min.checkerStringMinKind.has, (checker) => checker.definition.min)),

package/dist/dataParser/parsers/templateLiteral/createTemplateLiteralPattern.mjs

@@ -39,9 +39,9 @@ function createTemplateLiteralPattern(templatePart) {
         int: innerPipe(find(checkerIntKind.has), when$1(checkerIntKind.has, justReturn(true))),
     }), ({ int }) => {
         if (int) {
-            return "(?:[0-9]+)";
+            return "(?:-?[0-9]+)";
         }
-        return "(?:[0-9]+(\\.[0-9]+)?)";
+        return "(?:-?[0-9]+(?:\\.[0-9]+)?)";
     })), when(bigIntKind.has, () => "(?:[0-9]+n)"), when(booleanKind.has, () => "(?:true|false)"), when(nilKind.has, () => "(?:null)"), when(emptyKind.has, () => "(?:undefined)"), when(literalKind.has, (dataParser) => pipe(dataParser.definition.value, map((element) => createTemplateLiteralPattern([element])), join("|"), (pattern) => `(?:${pattern})`)), when(stringKind.has, (dataParser) => pipe(dataParser.definition.checkers, to({
         email: innerPipe(find(checkerEmailKind.has), when$1(checkerEmailKind.has, (checker) => pipe(checker.definition.pattern.source, replace(/^\^/, ""), replace(/\$$/, "")))),
         min: innerPipe(find(checkerStringMinKind.has), when$1(checkerStringMinKind.has, (checker) => checker.definition.min)),

package/dist/dataParser/parsers/templateLiteral/index.cjs

@@ -8,6 +8,9 @@ var pipe = require('../../../common/pipe.cjs');
 var override = require('../../../common/override.cjs');
 
 const templateLiteralKind = kind.createDataParserKind("template-literal");
+/**
+ * {@include dataParser/classic/templateLiteral/index.md}
+ */
 function templateLiteral(template, definition) {
     const pattern = pipe.pipe(createTemplateLiteralPattern.createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
     const self = base.dataParserInit(templateLiteralKind, {

package/dist/dataParser/parsers/templateLiteral/index.d.ts

@@ -1,4 +1,4 @@
-import { type Adaptor, type AnyTuple, type FixDeepFunctionInfer, type Kind, type NeverCoalescing } from "../../../common";
+import { type Adaptor, type AnyTuple, type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
 import { type DataParserCheckerStringMax, type DataParserCheckerStringMin, type DataParserCheckerStringRegex, type DataParserCheckerEmail, type DataParserDefinitionString, type DataParserString } from "../string";
@@ -13,26 +13,26 @@ import { type DataParserDefinitionUnion, type DataParserUnion } from "../union";
 import { type GetPropsWithValueExtends } from "../../../object";
 export * from "./createTemplateLiteralPattern";
 export type TemplateLiteralPrimitiveParts = (string | number | null | undefined | bigint | boolean);
-export type TemplateLiteralParts = (TemplateLiteralPrimitiveParts | DataParserString<Omit<DataParserDefinitionString, "checkers"> & {
+export type TemplateLiteralParts = (TemplateLiteralPrimitiveParts | DataParserString<SimplifyTopLevel<Omit<DataParserDefinitionString, "checkers"> & {
     readonly checkers: readonly (DataParserCheckerEmail | DataParserCheckerStringMax | DataParserCheckerStringMin | DataParserCheckerStringRegex)[];
-}> | DataParserNumber<Omit<DataParserDefinitionNumber, "checkers"> & {
+}>> | DataParserNumber<SimplifyTopLevel<Omit<DataParserDefinitionNumber, "checkers"> & {
     readonly checkers: readonly DataParserCheckerInt[];
-}> | DataParserBigInt<Omit<DataParserDefinitionBigInt, "checkers"> & {
+}>> | DataParserBigInt<SimplifyTopLevel<Omit<DataParserDefinitionBigInt, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserBoolean<Omit<DataParserDefinitionBoolean, "checkers"> & {
+}>> | DataParserBoolean<SimplifyTopLevel<Omit<DataParserDefinitionBoolean, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserLiteral<Omit<DataParserDefinitionLiteral, "checkers"> & {
+}>> | DataParserLiteral<SimplifyTopLevel<Omit<DataParserDefinitionLiteral, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserEmpty<Omit<DataParserDefinitionEmpty, "checkers"> & {
+}>> | DataParserEmpty<SimplifyTopLevel<Omit<DataParserDefinitionEmpty, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserNil<Omit<DataParserDefinitionNil, "checkers"> & {
+}>> | DataParserNil<SimplifyTopLevel<Omit<DataParserDefinitionNil, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserTemplateLiteral<Omit<DataParserDefinitionTemplateLiteral, "checkers"> & {
+}>> | DataParserTemplateLiteral<SimplifyTopLevel<Omit<DataParserDefinitionTemplateLiteral, "checkers"> & {
     readonly checkers: readonly [];
-}> | DataParserUnion<Omit<DataParserDefinitionUnion, "checkers" | "options"> & {
+}>> | DataParserUnion<SimplifyTopLevel<Omit<DataParserDefinitionUnion, "checkers" | "options"> & {
     readonly options: AnyTuple<Exclude<TemplateLiteralParts, TemplateLiteralPrimitiveParts>>;
     readonly checkers: readonly [];
-}>);
+}>>);
 export type TemplateLiteralShape = readonly [TemplateLiteralParts, ...TemplateLiteralParts[]];
 type EligibleTemplateLiteral = string | number | bigint | boolean | null | undefined;
 export type TemplateLiteralShapeOutput<GenericTemplate extends TemplateLiteralShape, GenericLastResult extends string = ""> = GenericTemplate extends readonly [
@@ -60,11 +60,37 @@ export interface DataParserTemplateLiteral<GenericDefinition extends DataParserD
         DataParserTemplateLiteralCheckers<Output<this>>,
         ...DataParserTemplateLiteralCheckers<Output<this>>[]
     ], GenericChecker>): DataParserTemplateLiteral<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTemplateLiteral>(definition: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for deterministic template literal strings.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.templateLiteral(template, definition?)` -> returns a template literal parser
+ * - Curried: not available
+ * 
+ * Validates that the input matches the provided template literal shape and pattern.
+ * 
+ * ```ts
+ * const parser = DP.templateLiteral(["user-", DP.number()]);
+ * const result = parser.parse("user-42");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: string
+ * }
+ * 
+ * const orderParser = DP.templateLiteral(["order-", DP.literal("vip"), "-", DP.number()]);
+ * const orderResult = orderParser.parse("order-vip-12");
+ * 
+ * const withCheckers = DP.templateLiteral(["id-", DP.number()], {
+ * 	checkers: [DP.checkerRefine((value) => value.endsWith("0"))],
+ * });
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/templateLiteral
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function templateLiteral<const GenericTemplate extends TemplateLiteralShape, const GenericDefinition extends Partial<Omit<DataParserDefinitionTemplateLiteral, "template" | "pattern">> = never>(template: GenericTemplate, definition?: GenericDefinition): DataParserTemplateLiteral<MergeDefinition<DataParserDefinitionTemplateLiteral, NeverCoalescing<GenericDefinition, {}> & {
     template: GenericTemplate;
 }>>;

package/dist/dataParser/parsers/templateLiteral/index.mjs

@@ -6,6 +6,9 @@ import { pipe } from '../../../common/pipe.mjs';
 import { createOverride } from '../../../common/override.mjs';
 
 const templateLiteralKind = createDataParserKind("template-literal");
+/**
+ * {@include dataParser/classic/templateLiteral/index.md}
+ */
 function templateLiteral(template, definition) {
     const pattern = pipe(createTemplateLiteralPattern(template), (result) => new RegExp(`^${result}$`));
     const self = dataParserInit(templateLiteralKind, {

package/dist/dataParser/parsers/time/index.cjs

@@ -13,6 +13,9 @@ var isTime = require('../../../date/isTime.cjs');
 var override = require('../../../common/override.cjs');
 
 const timeKind = kind.createDataParserKind("time");
+/**
+ * {@include dataParser/classic/time/index.md}
+ */
 function time(definition) {
     const self = base.dataParserInit(timeKind, {
         errorMessage: definition?.errorMessage,

package/dist/dataParser/parsers/time/index.d.ts

@@ -22,11 +22,37 @@ export interface DataParserTime<GenericDefinition extends DataParserDefinitionTi
         DataParserTimeCheckers,
         ...DataParserTimeCheckers[]
     ], GenericChecker>): DataParserTime<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
-    /**
-     * @deprecated Method with unreliable typing.
-     */
-    construct<const GenericDefinition extends DataParserDefinitionTime>(definition: GenericDefinition): DataParserTime<MergeDefinition<DataParserDefinitionTime, GenericDefinition>>;
 }
+/**
+ * Creates a data parser for TheTime values.
+ * 
+ * **Supported call styles:**
+ * - Classic: `DP.time(definition?)` -> returns a time parser
+ * - Curried: not available
+ * 
+ * Validates that the input is a TheTime, optionally applies coerce, and runs the configured checkers.
+ * 
+ * ```ts
+ * const parser = DP.time();
+ * const result = parser.parse("time0+");
+ * if (E.isRight(result)) {
+ * 	const value = unwrap(result);
+ * 	// value: TheTime
+ * }
+ * 
+ * const withCheckers = DP.time({
+ * 	checkers: [DP.checkerRefine((value) => value !== "time0+")],
+ * });
+ * 
+ * const coerceParser = DP.coerce.time();
+ * const coerceResult = coerceParser.parse("10:20:00");
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/dataParser/time
+ * 
+ * @namespace DP
+ * 
+ */
 export declare function time<const GenericDefinition extends Partial<DataParserDefinitionTime> = never>(definition?: GenericDefinition): DataParserTime<MergeDefinition<DataParserDefinitionTime, NeverCoalescing<GenericDefinition, {}>>>;
 export declare namespace time {
     var overrideHandler: import("../../../common").OverrideHandler<DataParserTime<DataParserDefinitionTime>>;