@j2blasco/ts-result 0.0.7 → 0.0.8

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 [Your Name]
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2025 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./result"), exports);
+__exportStar(require("./result-functions"), exports);

package/dist/cjs/result-functions.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.andThen = andThen;
+exports.andThenAsync = andThenAsync;
+function andThen(callback) {
+    return (result) => result.andThen(callback);
+}
+function andThenAsync(callback) {
+    return (result) => result.andThenAsync(callback);
+}

package/dist/cjs/result.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resultError = void 0;
+exports.unwrapSuccessResult = unwrapSuccessResult;
+exports.errorWithCode = errorWithCode;
+exports.errorUnkown = errorUnkown;
+exports.resultSuccessVoid = resultSuccessVoid;
+exports.resultSuccess = resultSuccess;
+exports.makeSafePromise = makeSafePromise;
+function unwrapSuccessResult(result) {
+    if (result instanceof ResultSuccessImp) {
+        return result['value'];
+    }
+    throw new Error('Unreachable code. Result is an error');
+}
+function errorWithCode(code, data) {
+    return {
+        code,
+        data,
+    };
+}
+function errorUnkown(message) {
+    return {
+        code: 'unknown',
+        data: { message },
+    };
+}
+function resultSuccessVoid() {
+    return new ResultSuccessImp(undefined);
+}
+function resultSuccess(value) {
+    return new ResultSuccessImp(value);
+}
+class resultError {
+    static unknown(message) {
+        return new ResultErrorImp(errorUnkown(message));
+    }
+    static withCode(code, data = {}) {
+        return new ResultErrorImp(errorWithCode(code, data));
+    }
+    static fromError(error) {
+        return new ResultErrorImp(error);
+    }
+}
+exports.resultError = resultError;
+class ResultSuccessImp {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    andThen(f) {
+        return f(this.value);
+    }
+    async andThenAsync(f) {
+        return await f(this.value);
+    }
+    catchError(_f) {
+        return this;
+    }
+    async catchErrorAsync(_f) {
+        return this;
+    }
+    unwrapOrThrow(_errorCallback) {
+        return this.value;
+    }
+}
+class ResultErrorImp {
+    error;
+    constructor(error) {
+        this.error = error;
+    }
+    andThen(_f) {
+        return this;
+    }
+    async andThenAsync(_f) {
+        return this;
+    }
+    catchError(f) {
+        return f(this.error);
+    }
+    async catchErrorAsync(f) {
+        return await f(this.error);
+    }
+    unwrapOrThrow(errorCallback) {
+        if (errorCallback !== undefined) {
+            errorCallback(this.error);
+        }
+        throw this.error;
+    }
+}
+function makeSafePromise(promise) {
+    return promise
+        .then((value) => resultSuccess(value))
+        .catch((error) => resultError.unknown(error.message));
+}

package/dist/cjs/utils/test/assert-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertType = assertType;
+exports.expectToCompile = expectToCompile;
+function assertType(_value) { }
+function expectToCompile() {
+    expect(true).toBe(true);
+}

package/package.json

@@ -1,36 +1,39 @@
-{
-  "name": "@j2blasco/ts-result",
-  "version": "0.0.7",
-  "description": "Result Monad for TypeScript",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "test": "jest",
-    "build": "tsc"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "type": "module",
-  "devDependencies": {
-    "@j2blasco/ts-pipe": "^0.0.3",
-    "@types/jest": "^29.5.14",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.3.2"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}
+{
+  "name": "@j2blasco/ts-result",
+  "version": "0.0.8",
+  "description": "Result Monad for TypeScript",  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },  "files": [
+    "dist/cjs",
+    "dist/esm", 
+    "types",
+    "README.md",
+    "LICENSE"
+  ],  "scripts": {
+    "test": "jest",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "clean": "rimraf dist types"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "type": "module",  "devDependencies": {
+    "@j2blasco/ts-pipe": "^0.0.4",
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.3.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/dist/result.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/result.test.js

@@ -1,55 +0,0 @@
-import { resultSuccess, resultError, unwrapSuccessResult, resultSuccessVoid, } from "./result";
-import { assertType, expectToCompile } from "./utils/test/assert-type";
-function createResult() {
-    return resultSuccessVoid();
-}
-describe("Result Monad", () => {
-    test("resultSuccess should create a success result", () => {
-        const success = resultSuccess("test");
-        expect(unwrapSuccessResult(success)).toBe("test");
-    });
-    test("resultError.unknown should create an unknown error result", () => {
-        const error = resultError.unknown("An error occurred");
-        try {
-            error.unwrapOrThrow();
-        }
-        catch (e) {
-            expect(e).toMatchObject({
-                code: "unknown",
-                data: { message: "An error occurred" },
-            });
-        }
-    });
-    test("resultError.withCode should create a coded error result", () => {
-        const error = resultError.withCode("test-code", {
-            detail: "Some details",
-        });
-        try {
-            error.unwrapOrThrow();
-        }
-        catch (e) {
-            expect(e).toMatchObject({
-                code: "test-code",
-                data: { detail: "Some details" },
-            });
-        }
-    });
-    test("Result Monad success should be chainable with inferred types - string -> int", () => {
-        const resultString = createResult();
-        const resultInt = resultString.andThen((value) => {
-            assertType(true);
-            return resultSuccess(42);
-        });
-        assertType(true);
-        expectToCompile();
-    });
-    test("Result Monad success should be chainable with inferred types - obj -> obj", () => {
-        const resultString = createResult();
-        const resultInt = resultString.andThen((value) => {
-            assertType(true);
-            return resultSuccess({ test2: "test" });
-        });
-        assertType(true);
-        expectToCompile();
-    });
-});