@duplojs/utils 1.4.59 → 1.5.0

package/dist/common/mimeType.cjs

@@ -1075,7 +1075,10 @@ const mimeType = (() => {
             results.set(extension, type);
         }
     }
-    return results;
+    return {
+        get: (extensionName) => results.get(extensionName.toLowerCase()),
+        set: (extensionName, mimeType) => void results.set(extensionName.toLowerCase(), mimeType.toLowerCase()),
+    };
 })();
 
 exports.mimeType = mimeType;

package/dist/common/mimeType.d.ts

@@ -1,11 +1,16 @@
+export interface MimeTypeStore {
+    get(extensionName: string): string | undefined;
+    set(extensionName: string, mimeType: string): void;
+}
 /**
- * Provides a map that resolves file extensions to their MIME types.
+ * Provides an object that resolves file extensions to their MIME types and allows custom registrations.
  * 
  * **Supported call styles:**
  * - Access: `mimeType.get(extension)` -> returns the MIME type or undefined
+ * - Registration: `mimeType.set(extension, mimeType)` -> stores or overrides a MIME type for an extension
  * 
  * Extensions are stored without the leading dot and should be passed in lower case.
- * When an extension is not present, the map returns `undefined`.
+ * When an extension is not present, `mimeType.get(...)` returns `undefined`.
  * 
  * ```ts
  * const jsonType = mimeType.get("json");
@@ -14,9 +19,13 @@
  * // svgType: "image/svg+xml"
  * const unknownType = mimeType.get("unknown");
  * // unknownType: undefined
+ * 
+ * mimeType.set("txtnull", "text-null/plain");
+ * const customType = mimeType.get("txtnull");
+ * // customType: "text-null/plain"
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/common/mimeType
  * 
  */
-export declare const mimeType: Map<string, string>;
+export declare const mimeType: MimeTypeStore;

package/dist/common/mimeType.mjs

@@ -1073,7 +1073,10 @@ const mimeType = (() => {
             results.set(extension, type);
         }
     }
-    return results;
+    return {
+        get: (extensionName) => results.get(extensionName.toLowerCase()),
+        set: (extensionName, mimeType) => void results.set(extensionName.toLowerCase(), mimeType.toLowerCase()),
+    };
 })();
 
 export { mimeType };

package/dist/dataParser/extended/nullable.cjs

@@ -8,7 +8,12 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/nullable/index.md}
  */
 function nullable(inner, definition) {
-    const self = baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {}, nullable.overrideHandler);
+    const self = baseExtended.dataParserExtendedInit(nullable$1.nullable(inner, definition), {
+        default: (self, value) => nullable(self.definition.inner, {
+            ...self.definition,
+            coalescingValue: value,
+        }),
+    }, nullable.overrideHandler);
     return self;
 }
 nullable.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/nullable");

package/dist/dataParser/extended/nullable.d.ts

@@ -1,4 +1,4 @@
-import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
@@ -13,6 +13,13 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
         ...dataParsers.DataParserNullableCheckers<Output<this>>[]
     ], GenericChecker>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserNullableExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
+    /**
+     * Alias to define the default value
+     * Using `default()` is equivalent to defining the `coalescingValue` in the dataParser definition.
+     */
+    default<GenericInput extends Output<GenericDefinition["inner"]>>(input: GenericInput): DataParserNullableExtended<SimplifyTopLevel<Omit<GenericDefinition, "coalescingValue"> & {
+        readonly coalescingValue: GenericInput;
+    }>>;
 }
 /**
  * Creates an extended nullable parser from another parser.
@@ -30,11 +37,13 @@ export interface DataParserNullableExtended<GenericDefinition extends dataParser
  * 	// value: string | null
  * }
  * 
- * const withCoalescing = DPE.nullable(DPE.number(), { coalescingValue: 0 });
+ * const withCoalescing = DPE.number().nullable().default(0);
  * const coalesced = withCoalescing.parse(null);
+ * // E.Error<DPE.DataParserError> | E.Success<number>
  * 
  * const nullableBool = DPE.nullable(DPE.boolean());
  * const boolResult = nullableBool.parse(true);
+ * // E.Error<DPE.DataParserError> | E.Success<boolean | null>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/nullable

package/dist/dataParser/extended/nullable.mjs

@@ -6,7 +6,12 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/nullable/index.md}
  */
 function nullable(inner, definition) {
-    const self = dataParserExtendedInit(nullable$1(inner, definition), {}, nullable.overrideHandler);
+    const self = dataParserExtendedInit(nullable$1(inner, definition), {
+        default: (self, value) => nullable(self.definition.inner, {
+            ...self.definition,
+            coalescingValue: value,
+        }),
+    }, nullable.overrideHandler);
     return self;
 }
 nullable.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/nullable");

package/dist/dataParser/extended/optional.cjs

@@ -8,7 +8,12 @@ var override = require('../../common/override.cjs');
  * {@include dataParser/extended/optional/index.md}
  */
 function optional(inner, definition) {
-    const self = baseExtended.dataParserExtendedInit(optional$1.optional(inner, definition), {}, optional.overrideHandler);
+    const self = baseExtended.dataParserExtendedInit(optional$1.optional(inner, definition), {
+        default: (self, value) => optional(self.definition.inner, {
+            ...self.definition,
+            coalescingValue: value,
+        }),
+    }, optional.overrideHandler);
     return self;
 }
 optional.overrideHandler = override.createOverride("@duplojs/utils/data-parser-extended/optional");

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

@@ -1,4 +1,4 @@
-import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing } from "../../common";
+import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
@@ -13,6 +13,13 @@ export interface DataParserOptionalExtended<GenericDefinition extends dataParser
         ...dataParsers.DataParserOptionalCheckers<Output<this>>[]
     ], GenericChecker>): DataParserOptionalExtended<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
     refine(theFunction: (input: Output<this>) => boolean, definition?: Partial<Omit<dataParsers.DataParserCheckerDefinitionRefine, "theFunction">>): DataParserOptionalExtended<AddCheckersToDefinition<GenericDefinition, readonly [dataParsers.CheckerRefineImplementation<Output<this>>]>>;
+    /**
+     * Alias to define the default value
+     * Using `default()` is equivalent to defining the `coalescingValue` in the dataParser definition.
+     */
+    default<GenericInput extends Output<GenericDefinition["inner"]>>(input: GenericInput): DataParserOptionalExtended<SimplifyTopLevel<Omit<GenericDefinition, "coalescingValue"> & {
+        readonly coalescingValue: GenericInput;
+    }>>;
 }
 /**
  * Creates an extended optional parser from another parser.
@@ -30,11 +37,13 @@ export interface DataParserOptionalExtended<GenericDefinition extends dataParser
  * 	// value: string | undefined
  * }
  * 
- * const withCoalescing = DPE.optional(DPE.number(), { coalescingValue: 0 });
+ * const withCoalescing = DPE.number().optional().default(0);
  * const coalesced = withCoalescing.parse(undefined);
+ * // E.Error<DPE.DataParserError> | E.Success<number>
  * 
  * const optionalBool = DPE.optional(DPE.boolean());
  * const boolResult = optionalBool.parse(true);
+ * // E.Error<DPE.DataParserError> | E.Success<boolean | undefined>
  * ```
  * 
  * @see https://utils.duplojs.dev/en/v1/api/dataParser/optional

package/dist/dataParser/extended/optional.mjs

@@ -6,7 +6,12 @@ import { createOverride } from '../../common/override.mjs';
  * {@include dataParser/extended/optional/index.md}
  */
 function optional(inner, definition) {
-    const self = dataParserExtendedInit(optional$1(inner, definition), {}, optional.overrideHandler);
+    const self = dataParserExtendedInit(optional$1(inner, definition), {
+        default: (self, value) => optional(self.definition.inner, {
+            ...self.definition,
+            coalescingValue: value,
+        }),
+    }, optional.overrideHandler);
     return self;
 }
 optional.overrideHandler = createOverride("@duplojs/utils/data-parser-extended/optional");

package/dist/generator/reduce.d.ts

@@ -15,7 +15,7 @@ export interface GeneratorReduceFunctionParams<GenericElement extends unknown =
     nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => GeneratorReduceNext<GenericOutput> : undefined;
     next(output: GenericOutput): GeneratorReduceNext<GenericOutput>;
     exit<GenericExitValue extends unknown>(output: GenericExitValue): GeneratorReduceExit<GenericExitValue>;
-    nextPush: GenericOutput extends readonly any[] ? (array: GenericOutput, ...values: GenericOutput) => GeneratorReduceExit<GenericOutput> : undefined;
+    nextPush: GenericOutput extends readonly any[] ? (array: GenericOutput, ...values: GenericOutput) => GeneratorReduceNext<GenericOutput> : undefined;
 }
 declare const generatorReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"generator-reduce-from", unknown>>;
 export interface GeneratorReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof generatorReduceFromKind.definition>, WrappedValue<GenericValue> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.4.59",
+  "version": "1.5.0",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"