@duplojs/utils 1.3.24 → 1.3.26

package/dist/array/index.cjs

@@ -43,6 +43,7 @@ var chunk = require('./chunk.cjs');
 var insert$2 = require('./insert.cjs');
 var isLastIndex = require('./isLastIndex.cjs');
 var select = require('./select.cjs');
+var lengthEqual = require('./lengthEqual.cjs');
 var _delete = require('./splice/delete.cjs');
 var insert = require('./splice/insert.cjs');
 var replace = require('./splice/replace.cjs');
@@ -104,6 +105,7 @@ exports.insert = insert$2.insert;
 exports.isLastIndex = isLastIndex.isLastIndex;
 exports.select = select.select;
 exports.selectTools = select.selectTools;
+exports.lengthEqual = lengthEqual.lengthEqual;
 exports.spliceDelete = _delete.spliceDelete;
 exports.spliceInsert = insert.spliceInsert;
 exports.spliceReplace = replace.spliceReplace;

package/dist/array/index.d.ts

@@ -46,3 +46,4 @@ export * from "./chunk";
 export * from "./insert";
 export * from "./isLastIndex";
 export * from "./select";
+export * from "./lengthEqual";

package/dist/array/index.mjs

@@ -41,6 +41,7 @@ export { chunk } from './chunk.mjs';
 export { insert } from './insert.mjs';
 export { isLastIndex } from './isLastIndex.mjs';
 export { select, selectTools } from './select.mjs';
+export { lengthEqual } from './lengthEqual.mjs';
 export { spliceDelete } from './splice/delete.mjs';
 export { spliceInsert } from './splice/insert.mjs';
 export { spliceReplace } from './splice/replace.mjs';

package/dist/array/lengthEqual.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function lengthEqual(...args) {
+    if (args.length === 1) {
+        const [minLength] = args;
+        return (array) => lengthEqual(array, minLength);
+    }
+    const [array, minLength] = args;
+    return array.length === minLength;
+}
+
+exports.lengthEqual = lengthEqual;

package/dist/array/lengthEqual.d.ts

@@ -0,0 +1,3 @@
+import { type CreateTuple } from "./types";
+export declare function lengthEqual<GenericArray extends readonly unknown[], GenericLength extends number>(length: GenericLength): (array: GenericArray) => array is CreateTuple<GenericArray[number], GenericLength>;
+export declare function lengthEqual<GenericArray extends readonly unknown[], GenericLength extends number>(array: GenericArray, length: GenericLength): array is CreateTuple<GenericArray[number], GenericLength>;

package/dist/array/lengthEqual.mjs

@@ -0,0 +1,10 @@
+function lengthEqual(...args) {
+    if (args.length === 1) {
+        const [minLength] = args;
+        return (array) => lengthEqual(array, minLength);
+    }
+    const [array, minLength] = args;
+    return array.length === minLength;
+}
+
+export { lengthEqual };

package/dist/array/types/createTuple.d.ts

@@ -1,2 +1,2 @@
 import { type IsEqual } from "../../common/types/isEqual";
-export type CreateTuple<GenericValue extends unknown, GenericLength extends number, GenericLastTuple extends unknown[] = []> = IsEqual<GenericLength, number> extends true ? GenericValue[] : [...GenericLastTuple, GenericValue] extends infer InferredResult extends any[] ? IsEqual<InferredResult["length"], GenericLength> extends true ? InferredResult : IsEqual<InferredResult["length"], 1000> extends true ? [...InferredResult, ...GenericValue[]] : CreateTuple<GenericValue, GenericLength, InferredResult> : never;
+export type CreateTuple<GenericValue extends unknown, GenericLength extends number, GenericLastTuple extends unknown[] = []> = IsEqual<GenericLength, number> extends true ? GenericValue[] : IsEqual<GenericLength, 0> extends true ? [] : [...GenericLastTuple, GenericValue] extends infer InferredResult extends any[] ? IsEqual<InferredResult["length"], GenericLength> extends true ? InferredResult : IsEqual<InferredResult["length"], 1000> extends true ? [...InferredResult, ...GenericValue[]] : CreateTuple<GenericValue, GenericLength, InferredResult> : never;

package/dist/dataParser/parsers/date.cjs

@@ -30,6 +30,14 @@ function date(definition) {
                 const isNegative = data < 0;
                 return `date${Math.abs(data)}${isNegative ? "-" : "+"}`;
             }
+            if (typeof data === "string") {
+                const date = new Date(data);
+                const timestamp = date.getTime();
+                if (isSafeTimestamp.isSafeTimestamp(timestamp)) {
+                    const isNegative = timestamp < 0;
+                    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+                }
+            }
         }
         const theDateMatch = typeof data === "string" && data.match(constants.theDateRegex);
         if (theDateMatch) {

package/dist/dataParser/parsers/date.mjs

@@ -28,6 +28,14 @@ function date(definition) {
                 const isNegative = data < 0;
                 return `date${Math.abs(data)}${isNegative ? "-" : "+"}`;
             }
+            if (typeof data === "string") {
+                const date = new Date(data);
+                const timestamp = date.getTime();
+                if (isSafeTimestamp(timestamp)) {
+                    const isNegative = timestamp < 0;
+                    return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+                }
+            }
         }
         const theDateMatch = typeof data === "string" && data.match(theDateRegex);
         if (theDateMatch) {

package/dist/either/index.cjs

@@ -3,6 +3,7 @@
 var hasInformation = require('./hasInformation.cjs');
 var whenHasInformation = require('./whenHasInformation.cjs');
 var kind = require('./kind.cjs');
+var safeCallback = require('./safeCallback.cjs');
 var create = require('./bool/create.cjs');
 var falsy = require('./bool/falsy.cjs');
 var truthy = require('./bool/truthy.cjs');
@@ -44,6 +45,9 @@ exports.hasInformation = hasInformation.hasInformation;
 exports.whenHasInformation = whenHasInformation.whenHasInformation;
 exports.createEitherKind = kind.createEitherKind;
 exports.eitherInformationKind = kind.eitherInformationKind;
+exports.callbackError = safeCallback.callbackError;
+exports.eitherCallbackErrorKind = safeCallback.eitherCallbackErrorKind;
+exports.safeCallback = safeCallback.safeCallback;
 exports.bool = create.bool;
 exports.boolFalsy = falsy.boolFalsy;
 exports.eitherBoolFalsyKind = falsy.eitherBoolFalsyKind;

package/dist/either/index.d.ts

@@ -8,3 +8,4 @@ export * from "./right";
 export * from "./hasInformation";
 export * from "./whenHasInformation";
 export * from "./kind";
+export * from "./safeCallback";

package/dist/either/index.mjs

@@ -1,6 +1,7 @@
 export { hasInformation } from './hasInformation.mjs';
 export { whenHasInformation } from './whenHasInformation.mjs';
 export { createEitherKind, eitherInformationKind } from './kind.mjs';
+export { callbackError, eitherCallbackErrorKind, safeCallback } from './safeCallback.mjs';
 export { bool } from './bool/create.mjs';
 export { boolFalsy, eitherBoolFalsyKind, isBoolFalsy, whenIsBoolFalsy } from './bool/falsy.mjs';
 export { boolTruthy, eitherBoolTruthyKind, isBoolTruthy, whenIsBoolTruthy } from './bool/truthy.mjs';

package/dist/either/safeCallback.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+var kind = require('./kind.cjs');
+var create = require('./left/create.cjs');
+
+const eitherCallbackErrorKind = kind.createEitherKind("callback-error");
+function callbackError(value) {
+    return eitherCallbackErrorKind.setTo(create.left("callback", value));
+}
+function safeCallback(theFunction) {
+    try {
+        return theFunction();
+    }
+    catch (error) {
+        return callbackError(error);
+    }
+}
+
+exports.callbackError = callbackError;
+exports.eitherCallbackErrorKind = eitherCallbackErrorKind;
+exports.safeCallback = safeCallback;

package/dist/either/safeCallback.d.ts

@@ -0,0 +1,9 @@
+import { type Kind } from "../common";
+import { type EitherLeft } from "./left";
+export declare const eitherCallbackErrorKind: import("../common").KindHandler<import("../common").KindDefinition<"@DuplojsUtilsEither/callback-error", unknown>>;
+type _EitherCallbackError = (EitherLeft<"callback", unknown> & Kind<typeof eitherCallbackErrorKind.definition>);
+export interface EitherCallbackError extends _EitherCallbackError {
+}
+export declare function callbackError(value: unknown): EitherCallbackError;
+export declare function safeCallback<GenericOutput extends unknown>(theFunction: () => GenericOutput): GenericOutput | EitherCallbackError;
+export {};

package/dist/either/safeCallback.mjs

@@ -0,0 +1,17 @@
+import { createEitherKind } from './kind.mjs';
+import { left } from './left/create.mjs';
+
+const eitherCallbackErrorKind = createEitherKind("callback-error");
+function callbackError(value) {
+    return eitherCallbackErrorKind.setTo(left("callback", value));
+}
+function safeCallback(theFunction) {
+    try {
+        return theFunction();
+    }
+    catch (error) {
+        return callbackError(error);
+    }
+}
+
+export { callbackError, eitherCallbackErrorKind, safeCallback };