@duplojs/utils 1.4.57 → 1.4.59

package/dist/generator/asyncGroup.d.ts

@@ -0,0 +1,39 @@
+import type { MaybePromise } from "../common";
+import { type GroupFunctionOutput, type GroupFunctionParams, type GroupResult } from "./group";
+/**
+ * Groups elements from an async iterable into an object by a group name.
+ * 
+ * **Supported call styles:**
+ * - Classic: `asyncGroup(asyncIterator, theFunction)` → returns a promise of grouped object
+ * - Curried: `asyncGroup(theFunction)` → returns a function waiting for the async iterator
+ * 
+ * Behavior:
+ * - The function receives `(element, { index, output })`
+ * - `theFunction` can return a value or a promise of value
+ * - `output` is `groupOutput` and returns `{ group, value }`
+ * - The input async iterator is not mutated
+ * 
+ * ```ts
+ * const asyncValues = (async function *() {
+ * 	yield Promise.resolve(1);
+ * 	yield 2;
+ * 	yield 3;
+ * 	yield 4;
+ * })();
+ * 
+ * await G.asyncGroup(
+ * 	asyncValues,
+ * 	(value, { output }) => output(value % 2 ? "odd" : "even", value),
+ * );
+ * // { odd: [1, 3], even: [2, 4] }
+ * ```
+ * 
+ * @see [`G.group`](https://utils.duplojs.dev/en/v1/api/generator/group) For sync iterables
+ * @see [`G.groupOutput`](https://utils.duplojs.dev/en/v1/api/generator/groupOutput) For creating group outputs
+ * @see https://utils.duplojs.dev/en/v1/api/generator/asyncGroup
+ * 
+ * @namespace G
+ * 
+ */
+export declare function asyncGroup<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(theFunction: (element: GenericElement, params: GroupFunctionParams) => MaybePromise<GenericOutput>): (asyncIterator: AsyncIterable<GenericElement>) => Promise<GroupResult<GenericOutput>>;
+export declare function asyncGroup<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(asyncIterator: AsyncIterable<GenericElement>, theFunction: (element: GenericElement, params: GroupFunctionParams) => MaybePromise<GenericOutput>): Promise<GroupResult<GenericOutput>>;

package/dist/generator/asyncGroup.mjs

@@ -0,0 +1,29 @@
+import { groupOutput } from './group.mjs';
+
+function asyncGroup(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (asyncIterator) => asyncGroup(asyncIterator, theFunction);
+    }
+    const [asyncIterator, theFunction] = args;
+    const result = {};
+    let index = 0;
+    return (async () => {
+        for await (const element of asyncIterator) {
+            const { group, value } = await theFunction(element, {
+                index,
+                output: groupOutput,
+            });
+            if (result[group]) {
+                result[group].push(value);
+            }
+            else {
+                result[group] = [value];
+            }
+            index++;
+        }
+        return result;
+    })();
+}
+
+export { asyncGroup };

package/dist/generator/group.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+function groupOutput(...args) {
+    if (args.length === 1) {
+        const [group] = args;
+        return (input) => groupOutput(group, input);
+    }
+    const [group, value] = args;
+    return {
+        group,
+        value,
+    };
+}
+function group(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => group(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    const result = {};
+    let index = 0;
+    for (const element of iterator) {
+        const { group, value } = theFunction(element, {
+            index,
+            output: groupOutput,
+        });
+        if (result[group]) {
+            result[group].push(value);
+        }
+        else {
+            result[group] = [value];
+        }
+        index++;
+    }
+    return result;
+}
+
+exports.group = group;
+exports.groupOutput = groupOutput;

package/dist/generator/group.d.ts

@@ -0,0 +1,101 @@
+import type { SimplifyTopLevel } from "../common";
+export interface GroupFunctionOutput<GenericGroupName extends string = string, GenericGroupValue extends unknown = unknown> {
+    group: GenericGroupName;
+    value: GenericGroupValue;
+}
+/**
+ * Creates a group output object for `group` and `asyncGroup`.
+ * 
+ * **Supported call styles:**
+ * - Classic: `groupOutput(group, value)` → returns a group output
+ * - Curried: `groupOutput(group)` → returns a function waiting for the value
+ * 
+ * Behavior:
+ * - The returned object always has `{ group, value }`
+ * - The `group` name is preserved as a string literal when possible
+ * 
+ * ```ts
+ * G.groupOutput(
+ * 	"even",
+ * 	2,
+ * ); // { group: "even", value: 2 }
+ * 
+ * pipe(
+ * 	"alpha",
+ * 	G.groupOutput("word"),
+ * ); // { group: "word", value: "alpha" }
+ * 
+ * G.groupOutput(
+ * 	"status",
+ * 	{
+ * 		ok: true,
+ * 	},
+ * ); // { group: "status", value: { ok: true } }
+ * ```
+ * 
+ * @see [`G.group`](https://utils.duplojs.dev/en/v1/api/generator/group) For grouping sync iterables
+ * @see [`G.asyncGroup`](https://utils.duplojs.dev/en/v1/api/generator/asyncGroup) For grouping async iterables
+ * @see https://utils.duplojs.dev/en/v1/api/generator/groupOutput
+ * 
+ * @namespace G
+ * 
+ */
+export declare function groupOutput<const GenericGroupName extends string, GenericGroupValue extends unknown>(group: GenericGroupName): (value: GenericGroupValue) => GroupFunctionOutput<GenericGroupName, GenericGroupValue>;
+export declare function groupOutput<const GenericGroupName extends string, GenericGroupValue extends unknown>(group: GenericGroupName, value: GenericGroupValue): GroupFunctionOutput<GenericGroupName, GenericGroupValue>;
+export interface GroupFunctionParams {
+    index: number;
+    output: typeof groupOutput;
+}
+export type GroupResult<GenericOutput extends GroupFunctionOutput> = SimplifyTopLevel<{
+    [Output in GenericOutput as Output["group"]]?: Output["value"][];
+}>;
+/**
+ * Groups elements from an iterable into an object by a group name.
+ * 
+ * **Supported call styles:**
+ * - Classic: `group(iterator, theFunction)` → returns a grouped object
+ * - Curried: `group(theFunction)` → returns a function waiting for the iterator
+ * 
+ * Behavior:
+ * - The function receives `(element, { index, output })`
+ * - `output` is `groupOutput` and returns `{ group, value }`
+ * - The input iterator is not mutated
+ * 
+ * ```ts
+ * G.group(
+ * 	[1, 2, 3, 4],
+ * 	(value, { output }) => output(value % 2 ? "odd" : "even", value),
+ * );
+ * // { odd: [1, 3], even: [2, 4] }
+ * 
+ * pipe(
+ * 	new Set(["alpha", "beta", "gamma"]),
+ * 	G.group((value, { index, output }) => output(
+ * 		"entry",
+ * 		{
+ * 			index,
+ * 			value,
+ * 		},
+ * 	)),
+ * );
+ * // { entry: [{ index: 0, value: "alpha" }, ...] }
+ * 
+ * G.group(
+ * 	["apple", "pear", "plum"],
+ * 	(value, { output }) => output(
+ * 		value.startsWith("p") ? "startsWithP" : "other",
+ * 		value.length,
+ * 	),
+ * );
+ * // { startsWithP: [5, 4, 4] }
+ * ```
+ * 
+ * @see [`G.groupOutput`](https://utils.duplojs.dev/en/v1/api/generator/groupOutput) For creating group outputs
+ * @see [`G.asyncGroup`](https://utils.duplojs.dev/en/v1/api/generator/asyncGroup) For async iterables
+ * @see https://utils.duplojs.dev/en/v1/api/generator/group
+ * 
+ * @namespace G
+ * 
+ */
+export declare function group<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(theFunction: (element: GenericElement, params: GroupFunctionParams) => GenericOutput): (iterator: Iterable<GenericElement>) => GroupResult<GenericOutput>;
+export declare function group<GenericElement extends unknown, GenericOutput extends GroupFunctionOutput>(iterator: Iterable<GenericElement>, theFunction: (element: GenericElement, params: GroupFunctionParams) => GenericOutput): GroupResult<GenericOutput>;

package/dist/generator/group.mjs

@@ -0,0 +1,36 @@
+function groupOutput(...args) {
+    if (args.length === 1) {
+        const [group] = args;
+        return (input) => groupOutput(group, input);
+    }
+    const [group, value] = args;
+    return {
+        group,
+        value,
+    };
+}
+function group(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => group(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    const result = {};
+    let index = 0;
+    for (const element of iterator) {
+        const { group, value } = theFunction(element, {
+            index,
+            output: groupOutput,
+        });
+        if (result[group]) {
+            result[group].push(value);
+        }
+        else {
+            result[group] = [value];
+        }
+        index++;
+    }
+    return result;
+}
+
+export { group, groupOutput };

package/dist/generator/index.cjs

@@ -11,6 +11,8 @@ var loop = require('./loop.cjs');
 var asyncLoop = require('./asyncLoop.cjs');
 var chunk = require('./chunk.cjs');
 var asyncChunk = require('./asyncChunk.cjs');
+var group = require('./group.cjs');
+var asyncGroup = require('./asyncGroup.cjs');
 
 /**
  * {@include generator/index.md}
@@ -28,3 +30,6 @@ exports.loop = loop.loop;
 exports.asyncLoop = asyncLoop.asyncLoop;
 exports.chunk = chunk.chunk;
 exports.asyncChunk = asyncChunk.asyncChunk;
+exports.group = group.group;
+exports.groupOutput = group.groupOutput;
+exports.asyncGroup = asyncGroup.asyncGroup;

package/dist/generator/index.d.ts

@@ -17,6 +17,7 @@
  * - reduce helpers (`G.reduceFrom`)
  * - control and execution (`G.loop`, `G.execute`)
  * - batching (`G.chunk`)
+ * - grouping (`G.group`, `G.groupOutput`, `G.asyncGroup`)
  * - async variants (`G.asyncMap`, `G.asyncFilter`, `G.asyncReduce`, `G.asyncLoop`, `G.asyncChunk`)
  * 
  * @see https://utils.duplojs.dev/en/v1/api/generator
@@ -35,3 +36,5 @@ export * from "./loop";
 export * from "./asyncLoop";
 export * from "./chunk";
 export * from "./asyncChunk";
+export * from "./group";
+export * from "./asyncGroup";

package/dist/generator/index.mjs

@@ -9,6 +9,8 @@ export { loop } from './loop.mjs';
 export { asyncLoop } from './asyncLoop.mjs';
 export { chunk } from './chunk.mjs';
 export { asyncChunk } from './asyncChunk.mjs';
+export { group, groupOutput } from './group.mjs';
+export { asyncGroup } from './asyncGroup.mjs';
 
 /**
  * {@include generator/index.md}

package/dist/index.cjs

@@ -27,15 +27,12 @@ var sleep = require('./common/sleep.cjs');
 var stringToBytes = require('./common/stringToBytes.cjs');
 var mimeType = require('./common/mimeType.cjs');
 var stringToMillisecond = require('./common/stringToMillisecond.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');
 var unwrapGroup = require('./common/unwrapGroup.cjs');
 var asyncLoop = require('./common/asyncLoop.cjs');
 var asyncRetry = require('./common/asyncRetry.cjs');
 var wrapValue = require('./common/wrapValue.cjs');
-var toString = require('./common/toString.cjs');
 var innerPipe = require('./common/innerPipe.cjs');
 var asyncInnerPipe = require('./common/asyncInnerPipe.cjs');
 var loop = require('./common/loop.cjs');
@@ -65,6 +62,8 @@ var toCurriedPredicate = require('./common/toCurriedPredicate.cjs');
 var pipeCall = require('./common/pipeCall.cjs');
 var asserts = require('./common/asserts.cjs');
 var path = require('./common/path.cjs');
+var transformer = require('./common/transformer.cjs');
+var toRegExp = require('./common/toRegExp.cjs');
 
 
 
@@ -113,8 +112,6 @@ exports.stringToBytes = stringToBytes.stringToBytes;
 exports.mimeType = mimeType.mimeType;
 exports.InvalidMillisecondInStringError = stringToMillisecond.InvalidMillisecondInStringError;
 exports.stringToMillisecond = stringToMillisecond.stringToMillisecond;
-exports.toJSON = toJSON.toJSON;
-exports.toTransform = toTransform.toTransform;
 exports.toWrappedValue = toWrappedValue.toWrappedValue;
 exports.unwrap = unwrap.unwrap;
 exports.unwrapGroup = unwrapGroup.unwrapGroup;
@@ -125,7 +122,6 @@ exports.isRuntimeWrappedValueKey = wrapValue.isRuntimeWrappedValueKey;
 exports.isWrappedValue = wrapValue.isWrappedValue;
 exports.keyWrappedValue = wrapValue.keyWrappedValue;
 exports.wrapValue = wrapValue.wrapValue;
-exports.toString = toString.toString;
 exports.innerPipe = innerPipe.innerPipe;
 exports.asyncInnerPipe = asyncInnerPipe.asyncInnerPipe;
 exports.loop = loop.loop;
@@ -161,3 +157,8 @@ Object.defineProperty(exports, "Path", {
 	enumerable: true,
 	get: function () { return path.Path; }
 });
+exports.createTransformer = transformer.createTransformer;
+exports.toJSON = transformer.toJSON;
+exports.toNative = transformer.toNative;
+exports.transformer = transformer.transformer;
+exports.toRegExp = toRegExp.toRegExp;

package/dist/index.mjs

@@ -49,15 +49,12 @@ export { sleep } from './common/sleep.mjs';
 export { InvalidBytesInStringError, stringToBytes } from './common/stringToBytes.mjs';
 export { mimeType } from './common/mimeType.mjs';
 export { InvalidMillisecondInStringError, stringToMillisecond } from './common/stringToMillisecond.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';
 export { unwrapGroup } from './common/unwrapGroup.mjs';
 export { asyncLoop } from './common/asyncLoop.mjs';
 export { createAsyncRetry, useAsyncRetry } from './common/asyncRetry.mjs';
 export { isRuntimeWrappedValueKey, isWrappedValue, keyWrappedValue, wrapValue } from './common/wrapValue.mjs';
-export { toString } from './common/toString.mjs';
 export { innerPipe } from './common/innerPipe.mjs';
 export { asyncInnerPipe } from './common/asyncInnerPipe.mjs';
 export { loop } from './common/loop.mjs';
@@ -87,3 +84,5 @@ export { toCurriedPredicate } from './common/toCurriedPredicate.mjs';
 export { pipeCall } from './common/pipeCall.mjs';
 export { AssertsError, asserts } from './common/asserts.mjs';
 export { Path } from './common/path.mjs';
+export { createTransformer, toJSON, toNative, transformer } from './common/transformer.mjs';
+export { toRegExp } from './common/toRegExp.mjs';

package/dist/metadata.json

@@ -612,6 +612,15 @@
                 },
                 {
                   "name": "string.mjs"
+                },
+                {
+                  "name": "time.cjs"
+                },
+                {
+                  "name": "time.d.ts"
+                },
+                {
+                  "name": "time.mjs"
                 }
               ]
             },
@@ -1551,40 +1560,31 @@
           "name": "toCurriedPredicate.mjs"
         },
         {
-          "name": "toJSON.cjs"
+          "name": "toRegExp.cjs"
         },
         {
-          "name": "toJSON.d.ts"
+          "name": "toRegExp.d.ts"
         },
         {
-          "name": "toJSON.mjs"
+          "name": "toRegExp.mjs"
         },
         {
-          "name": "toString.cjs"
-        },
-        {
-          "name": "toString.d.ts"
-        },
-        {
-          "name": "toString.mjs"
+          "name": "toWrappedValue.cjs"
         },
         {
-          "name": "toTransform.cjs"
+          "name": "toWrappedValue.d.ts"
         },
         {
-          "name": "toTransform.d.ts"
+          "name": "toWrappedValue.mjs"
         },
         {
-          "name": "toTransform.mjs"
+          "name": "transformer.cjs"
         },
         {
-          "name": "toWrappedValue.cjs"
+          "name": "transformer.d.ts"
         },
         {
-          "name": "toWrappedValue.d.ts"
-        },
-        {
-          "name": "toWrappedValue.mjs"
+          "name": "transformer.mjs"
         },
         {
           "name": "truthy.cjs"
@@ -3032,16 +3032,16 @@
               "name": "month.d.ts"
             },
             {
-              "name": "spoolingDate.d.ts"
+              "name": "serializedTheDate.d.ts"
             },
             {
-              "name": "spoolingTime.d.ts"
+              "name": "serializedTheTime.d.ts"
             },
             {
-              "name": "theDate.d.ts"
+              "name": "spoolingDate.d.ts"
             },
             {
-              "name": "theTime.d.ts"
+              "name": "spoolingTime.d.ts"
             },
             {
               "name": "time.d.ts"
@@ -3096,24 +3096,6 @@
         {
           "name": "createOrThrow.mjs"
         },
-        {
-          "name": "createTheDate.cjs"
-        },
-        {
-          "name": "createTheDate.d.ts"
-        },
-        {
-          "name": "createTheDate.mjs"
-        },
-        {
-          "name": "createTheTime.cjs"
-        },
-        {
-          "name": "createTheTime.d.ts"
-        },
-        {
-          "name": "createTheTime.mjs"
-        },
         {
           "name": "createTime.cjs"
         },
@@ -3204,6 +3186,24 @@
         {
           "name": "isSafeTimeValue.mjs"
         },
+        {
+          "name": "isSerializedTheDate.cjs"
+        },
+        {
+          "name": "isSerializedTheDate.d.ts"
+        },
+        {
+          "name": "isSerializedTheDate.mjs"
+        },
+        {
+          "name": "isSerializedTheTime.cjs"
+        },
+        {
+          "name": "isSerializedTheTime.d.ts"
+        },
+        {
+          "name": "isSerializedTheTime.mjs"
+        },
         {
           "name": "isTime.cjs"
         },
@@ -3213,6 +3213,15 @@
         {
           "name": "isTime.mjs"
         },
+        {
+          "name": "kind.cjs"
+        },
+        {
+          "name": "kind.d.ts"
+        },
+        {
+          "name": "kind.mjs"
+        },
         {
           "name": "makeSafeTimestamp.cjs"
         },
@@ -3285,6 +3294,15 @@
         {
           "name": "round.mjs"
         },
+        {
+          "name": "serialize.cjs"
+        },
+        {
+          "name": "serialize.d.ts"
+        },
+        {
+          "name": "serialize.mjs"
+        },
         {
           "name": "sort.cjs"
         },
@@ -3303,6 +3321,24 @@
         {
           "name": "sortTimes.mjs"
         },
+        {
+          "name": "theDate.cjs"
+        },
+        {
+          "name": "theDate.d.ts"
+        },
+        {
+          "name": "theDate.mjs"
+        },
+        {
+          "name": "theTime.cjs"
+        },
+        {
+          "name": "theTime.d.ts"
+        },
+        {
+          "name": "theTime.mjs"
+        },
         {
           "name": "timezone.cjs"
         },
@@ -3813,6 +3849,15 @@
         {
           "name": "asyncFilter.mjs"
         },
+        {
+          "name": "asyncGroup.cjs"
+        },
+        {
+          "name": "asyncGroup.d.ts"
+        },
+        {
+          "name": "asyncGroup.mjs"
+        },
         {
           "name": "asyncLoop.cjs"
         },
@@ -3867,6 +3912,15 @@
         {
           "name": "filter.mjs"
         },
+        {
+          "name": "group.cjs"
+        },
+        {
+          "name": "group.d.ts"
+        },
+        {
+          "name": "group.mjs"
+        },
         {
           "name": "index.cjs"
         },

package/dist/object/entries.cjs

@@ -7,8 +7,13 @@ var kind = require('../common/kind.cjs');
  * {@include object/entries/index.md}
  */
 function entries(object) {
-    return Object.entries(object)
-        .filter(([key]) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key)) {
+            result.push([key, object[key]]);
+        }
+    }
+    return result;
 }
 /**
  * @deprecated Not ignore kind key.

package/dist/object/entries.mjs

@@ -5,8 +5,13 @@ import { isRuntimeKind } from '../common/kind.mjs';
  * {@include object/entries/index.md}
  */
 function entries(object) {
-    return Object.entries(object)
-        .filter(([key]) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!isRuntimeWrappedValueKey(key) && !isRuntimeKind(key)) {
+            result.push([key, object[key]]);
+        }
+    }
+    return result;
 }
 /**
  * @deprecated Not ignore kind key.

package/dist/object/keys.cjs

@@ -7,8 +7,13 @@ var kind = require('../common/kind.cjs');
  * {@include object/keys/index.md}
  */
 function keys(object) {
-    return Object.keys(object)
-        .filter((key) => !wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!wrapValue.isRuntimeWrappedValueKey(key) && !kind.isRuntimeKind(key)) {
+            result.push(key);
+        }
+    }
+    return result;
 }
 
 exports.keys = keys;

package/dist/object/keys.d.ts

@@ -31,4 +31,4 @@
  * @namespace O
  * 
  */
-export declare function keys<GenericObject extends object>(object: GenericObject): (Exclude<keyof GenericObject, symbol>)[];
+export declare function keys<GenericObject extends object>(object: GenericObject): (`${Exclude<keyof GenericObject, symbol>}`)[];

package/dist/object/keys.mjs

@@ -5,8 +5,13 @@ import { isRuntimeKind } from '../common/kind.mjs';
  * {@include object/keys/index.md}
  */
 function keys(object) {
-    return Object.keys(object)
-        .filter((key) => !isRuntimeWrappedValueKey(key) && !isRuntimeKind(key));
+    const result = [];
+    for (const key in object) {
+        if (!isRuntimeWrappedValueKey(key) && !isRuntimeKind(key)) {
+            result.push(key);
+        }
+    }
+    return result;
 }
 
 export { keys };

package/package.json

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