@duplojs/utils 1.3.25 → 1.3.26

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 };