@shirudo/result 0.0.6 → 1.0.0

package/dist/mapOrElse-H-GvAUka.cjs

@@ -0,0 +1,137 @@
+const require_errors = require('./errors-D2EMzJQl.cjs');
+
+//#region src/core/fold.ts
+/**
+* Folds the Result into a single value by applying one of two functions.
+* The end of the pipe.
+*
+* This is the pipe operator equivalent of the `.fold()` instance method.
+*/
+function fold(handlers) {
+	return (source) => {
+		if (source.isOk()) return handlers.ok(source.value);
+		if (source.isErr()) return handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("fold");
+	};
+}
+
+//#endregion
+//#region src/core/foldAsync.ts
+/**
+* Async version of `fold`. Folds the Result into a single value asynchronously.
+* The end of the pipe.
+*
+* This is the async pipe operator equivalent of the `.fold()` instance method.
+*/
+function foldAsync(handlers) {
+	return async (source) => {
+		if (source.isOk()) return await handlers.ok(source.value);
+		if (source.isErr()) return await handlers.err(source.error);
+		throw new require_errors.InvalidResultStateError("foldAsync");
+	};
+}
+
+//#endregion
+//#region src/core/and.ts
+/**
+* Combines two Results. Returns the second one only if the first is Ok.
+* Corresponds to Rust `and`.
+*/
+function and(result, other) {
+	if (result.isOk()) return other;
+	if (result.isErr()) return result;
+	throw new require_errors.InvalidResultStateError("and");
+}
+
+//#endregion
+//#region src/core/or.ts
+/**
+* Fallback to another Result if the first is Err.
+* Corresponds to Rust `or`.
+*/
+function or(result, other) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return other;
+	throw new require_errors.InvalidResultStateError("or");
+}
+
+//#endregion
+//#region src/core/orElse.ts
+/**
+* Fallback with a function that returns a Result.
+* Corresponds to Rust `or_else`.
+*/
+function orElse(result, fn) {
+	if (result.isOk()) return result;
+	if (result.isErr()) return fn(result.error);
+	throw new require_errors.InvalidResultStateError("orElse");
+}
+
+//#endregion
+//#region src/core/mapOr.ts
+/**
+* Transforms the value or returns a default value.
+* Corresponds to Rust `map_or`.
+*/
+function mapOr(result, defaultValue, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultValue;
+	throw new require_errors.InvalidResultStateError("mapOr");
+}
+
+//#endregion
+//#region src/core/mapOrElse.ts
+/**
+* Transforms the value or calculates a default value using a function.
+* Corresponds to Rust `map_or_else`.
+*/
+function mapOrElse(result, defaultFn, fn) {
+	if (result.isOk()) return fn(result.value);
+	if (result.isErr()) return defaultFn(result.error);
+	throw new require_errors.InvalidResultStateError("mapOrElse");
+}
+
+//#endregion
+Object.defineProperty(exports, 'and', {
+  enumerable: true,
+  get: function () {
+    return and;
+  }
+});
+Object.defineProperty(exports, 'fold', {
+  enumerable: true,
+  get: function () {
+    return fold;
+  }
+});
+Object.defineProperty(exports, 'foldAsync', {
+  enumerable: true,
+  get: function () {
+    return foldAsync;
+  }
+});
+Object.defineProperty(exports, 'mapOr', {
+  enumerable: true,
+  get: function () {
+    return mapOr;
+  }
+});
+Object.defineProperty(exports, 'mapOrElse', {
+  enumerable: true,
+  get: function () {
+    return mapOrElse;
+  }
+});
+Object.defineProperty(exports, 'or', {
+  enumerable: true,
+  get: function () {
+    return or;
+  }
+});
+Object.defineProperty(exports, 'orElse', {
+  enumerable: true,
+  get: function () {
+    return orElse;
+  }
+});
+//# sourceMappingURL=mapOrElse-H-GvAUka.cjs.map

package/dist/mapOrElse-H-GvAUka.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapOrElse-H-GvAUka.cjs","names":["InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError","InvalidResultStateError"],"sources":["../src/core/fold.ts","../src/core/foldAsync.ts","../src/core/and.ts","../src/core/or.ts","../src/core/orElse.ts","../src/core/mapOr.ts","../src/core/mapOrElse.ts"],"sourcesContent":["import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Folds the Result into a single value by applying one of two functions.\n * The end of the pipe.\n *\n * This is the pipe operator equivalent of the `.fold()` instance method.\n */\nexport function fold<T, E, R>(handlers: { ok: (val: T) => R; err: (e: E) => R }) {\n    return (source: Result<T, E>): R => {\n        if (source.isOk()) {\n            return handlers.ok(source.value);\n        }\n        if (source.isErr()) return handlers.err(source.error);\n        throw new InvalidResultStateError('fold');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Async version of `fold`. Folds the Result into a single value asynchronously.\n * The end of the pipe.\n *\n * This is the async pipe operator equivalent of the `.fold()` instance method.\n */\nexport function foldAsync<T, E, R>(handlers: { ok: (val: T) => Promise<R>; err: (e: E) => Promise<R> }) {\n    return async (source: Result<T, E>): Promise<R> => {\n        if (source.isOk()) {\n            return await handlers.ok(source.value);\n        }\n        if (source.isErr()) return await handlers.err(source.error);\n        throw new InvalidResultStateError('foldAsync');\n    };\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Combines two Results. Returns the second one only if the first is Ok.\n * Corresponds to Rust `and`.\n */\nexport function and<T, E, U>(result: Result<T, E>, other: Result<U, E>): Result<U, E> {\n    if (result.isOk()) return other;\n    if (result.isErr()) return result as unknown as Result<U, E>;\n    throw new InvalidResultStateError('and');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback to another Result if the first is Err.\n * Corresponds to Rust `or`.\n */\nexport function or<T, E, F>(result: Result<T, E>, other: Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return other;\n    throw new InvalidResultStateError('or');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Fallback with a function that returns a Result.\n * Corresponds to Rust `or_else`.\n */\nexport function orElse<T, E, F>(result: Result<T, E>, fn: (error: E) => Result<T, F>): Result<T, F> {\n    if (result.isOk()) return result as unknown as Result<T, F>;\n    if (result.isErr()) return fn(result.error);\n    throw new InvalidResultStateError('orElse');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or returns a default value.\n * Corresponds to Rust `map_or`.\n */\nexport function mapOr<T, E, U>(result: Result<T, E>, defaultValue: U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultValue;\n    throw new InvalidResultStateError('mapOr');\n}\n","import type { Result } from './result';\nimport { InvalidResultStateError } from '../errors';\n\n/**\n * Transforms the value or calculates a default value using a function.\n * Corresponds to Rust `map_or_else`.\n */\nexport function mapOrElse<T, E, U>(result: Result<T, E>, defaultFn: (error: E) => U, fn: (value: T) => U): U {\n    if (result.isOk()) return fn(result.value);\n    if (result.isErr()) return defaultFn(result.error);\n    throw new InvalidResultStateError('mapOrElse');\n}\n"],"mappings":";;;;;;;;;AASA,SAAgB,KAAc,UAAmD;AAC7E,SAAQ,WAA4B;AAChC,MAAI,OAAO,MAAM,CACb,QAAO,SAAS,GAAG,OAAO,MAAM;AAEpC,MAAI,OAAO,OAAO,CAAE,QAAO,SAAS,IAAI,OAAO,MAAM;AACrD,QAAM,IAAIA,uCAAwB,OAAO;;;;;;;;;;;;ACNjD,SAAgB,UAAmB,UAAqE;AACpG,QAAO,OAAO,WAAqC;AAC/C,MAAI,OAAO,MAAM,CACb,QAAO,MAAM,SAAS,GAAG,OAAO,MAAM;AAE1C,MAAI,OAAO,OAAO,CAAE,QAAO,MAAM,SAAS,IAAI,OAAO,MAAM;AAC3D,QAAM,IAAIC,uCAAwB,YAAY;;;;;;;;;;ACRtD,SAAgB,IAAa,QAAsB,OAAmC;AAClF,KAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,KAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,OAAM,IAAIC,uCAAwB,MAAM;;;;;;;;;ACH5C,SAAgB,GAAY,QAAsB,OAAmC;AACjF,KAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,KAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,OAAM,IAAIC,uCAAwB,KAAK;;;;;;;;;ACH3C,SAAgB,OAAgB,QAAsB,IAA8C;AAChG,KAAI,OAAO,MAAM,CAAE,QAAO;AAC1B,KAAI,OAAO,OAAO,CAAE,QAAO,GAAG,OAAO,MAAM;AAC3C,OAAM,IAAIC,uCAAwB,SAAS;;;;;;;;;ACH/C,SAAgB,MAAe,QAAsB,cAAiB,IAAwB;AAC1F,KAAI,OAAO,MAAM,CAAE,QAAO,GAAG,OAAO,MAAM;AAC1C,KAAI,OAAO,OAAO,CAAE,QAAO;AAC3B,OAAM,IAAIC,uCAAwB,QAAQ;;;;;;;;;ACH9C,SAAgB,UAAmB,QAAsB,WAA4B,IAAwB;AACzG,KAAI,OAAO,MAAM,CAAE,QAAO,GAAG,OAAO,MAAM;AAC1C,KAAI,OAAO,OAAO,CAAE,QAAO,UAAU,OAAO,MAAM;AAClD,OAAM,IAAIC,uCAAwB,YAAY"}

package/dist/operators.cjs

@@ -0,0 +1,33 @@
+const require_result = require('./result-CY-KIivk.cjs');
+const require_mapOrElse = require('./mapOrElse-H-GvAUka.cjs');
+
+exports.and = require_mapOrElse.and;
+exports.bimap = require_result.bimap;
+exports.combine = require_result.combine;
+exports.filter = require_result.filter;
+exports.filterAsync = require_result.filterAsync;
+exports.flatMap = require_result.flatMap;
+exports.flatMapAsync = require_result.flatMapAsync;
+exports.fold = require_mapOrElse.fold;
+exports.foldAsync = require_mapOrElse.foldAsync;
+exports.map = require_result.map;
+exports.mapAsync = require_result.mapAsync;
+exports.mapBoth = require_result.mapBoth;
+exports.mapErr = require_result.mapErr;
+exports.mapErrAsync = require_result.mapErrAsync;
+exports.mapOr = require_mapOrElse.mapOr;
+exports.mapOrElse = require_mapOrElse.mapOrElse;
+exports.match = require_result.match;
+exports.matchAsync = require_result.matchAsync;
+exports.or = require_mapOrElse.or;
+exports.orElse = require_mapOrElse.orElse;
+exports.recover = require_result.recover;
+exports.recoverWith = require_result.recoverWith;
+exports.swap = require_result.swap;
+exports.tap = require_result.tap;
+exports.tapAsync = require_result.tapAsync;
+exports.tryCatch = require_result.tryCatch;
+exports.tryCatchAsync = require_result.tryCatchAsync;
+exports.tryMap = require_result.tryMap;
+exports.tryMapAsync = require_result.tryMapAsync;
+exports.zip = require_result.zip;

package/dist/operators.d.cts

@@ -0,0 +1,3 @@
+import { A as recover, B as combine, C as flatMapAsync, D as tryMap, F as flatMap, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, V as zip, b as matchAsync, j as recoverWith, k as swap, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-Br6tAIIu.cjs";
+import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-DIe7LkYV.cjs";
+export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };

package/dist/operators.d.mts

@@ -0,0 +1,3 @@
+import { A as recover, B as combine, C as flatMapAsync, D as tryMap, F as flatMap, I as bimap, L as mapBoth, M as match, N as filter, O as tryCatch, P as tap, R as mapErr, S as tapAsync, T as mapAsync, V as zip, b as matchAsync, j as recoverWith, k as swap, v as tryMapAsync, w as mapErrAsync, x as filterAsync, y as tryCatchAsync, z as map } from "./sequence-C0jlR3AY.mjs";
+import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B5gx9x2E.mjs";
+export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };

package/dist/operators.mjs

@@ -0,0 +1,4 @@
+import { A as flatMap, C as tryCatch, D as match, E as recoverWith, F as combine, I as zip, M as mapBoth, N as mapErr, O as filter, P as map, S as tryMap, T as recover, _ as tapAsync, b as mapAsync, g as filterAsync, h as matchAsync, j as bimap, k as tap, m as tryCatchAsync, p as tryMapAsync, v as flatMapAsync, w as swap, y as mapErrAsync } from "./result-DKKaNdOx.mjs";
+import { a as and, i as or, n as mapOr, o as foldAsync, r as orElse, s as fold, t as mapOrElse } from "./mapOrElse-B0_4r6Jn.mjs";
+
+export { and, bimap, combine, filter, filterAsync, flatMap, flatMapAsync, fold, foldAsync, map, mapAsync, mapBoth, mapErr, mapErrAsync, mapOr, mapOrElse, match, matchAsync, or, orElse, recover, recoverWith, swap, tap, tapAsync, tryCatch, tryCatchAsync, tryMap, tryMapAsync, zip };