Methods for option

package.json

@@ -1,19 +1,22 @@
 {
   "name": "@leanmind/monads",
-  "main": "dist/index.js",
-  "module": "dist/index.esm.js",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
   "types": "dist/index.d.ts",
   "version": "0.0.0-semantically-released",
   "description": "A collection of monads implemented in TypeScript using object-oriented programming.",
   "keywords": [
     "functional-programming",
     "monads",
     "typescript",
-    "oop"
+    "oop",
+    "error-handling"
   ],
   "scripts": {
     "analize": "npm run lint:fix && npm run compile",
-    "build": "npm run lint:fix && tsc",
+    "build": "npm run lint:fix && npm run compile:commonjs && npm run compile:esm",
+    "compile:commonjs": "tsc --outDir dist/cjs --module commonjs",
+    "compile:esm": "tsc --outDir dist/esm --module esnext",
     "compile": "tsc --noEmit",
     "compile:watch": "npm run compile -- --watch",
     "compile:build": "tsc -b",

src/option/option.test.ts

@@ -49,4 +49,12 @@ describe('Option monad', () => {
   ])('$type should handle isSome operation correctly', ({ option, expected }) => {
     expect(option.isSome()).toEqual(expected);
   });
+
+  it('should create a Some', () => {
+    expect(Option.some(2)).toEqual(new Some(2));
+  });
+
+  it('should create a None', () => {
+    expect(Option.none()).toEqual(new None());
+  });
 });

src/option/option.ts

@@ -1,4 +1,4 @@
-import { Nullable } from '../types';
+import { Present, Nullable } from '../types';
 import { Monad } from '../monad';
 import { Matchable } from '../match';
 
@@ -26,6 +26,30 @@ abstract class Option<T> implements Monad<T>, Matchable<T, undefined> {
     return new Some(value);
   }
 
+  /**
+   * Creates an `Option` instance from a value.
+   * @template T The type of the value.
+   * @param {Present<T>} value The nullable value.
+   * @returns {Some<T>} A `Some` instance of the value
+   * @example
+   * const some = Option.some(5);
+   * some.match(console.log, () => console.log('none')); // 5
+   */
+  static some<T>(value: Present<T>): Option<T> {
+    return new Some(value);
+  }
+
+  /**
+   * Creates a `None` instance.
+   * @returns {None} A `None` instance.
+   * @example
+   * const none = Option.none();
+   * none.match(console.log, () => console.log('none')); // none
+   */
+  static none<T>(): Option<T> {
+    return new None();
+  }
+
   /**
    * Creates an `Option` instance from a `Matchable` instance.
    * @template T The type of the value.

src/try/try.test.ts

@@ -35,7 +35,7 @@ describe('Try monad', () => {
       typeMatchable: 'None',
       tryType: 'Failure',
       matchable: Option.of<number>(undefined),
-      expected: Failure.NO_ERROR_PROVIDED,
+      expected: new Failure(new Error('No error provided')),
     },
   ])('$tryType should be created from $typeMatchable', ({ matchable, expected }) => {
     expect(Try.from(matchable)).toEqual(expected);

src/types.ts

@@ -1 +1,2 @@
 export type Nullable<T> = T | null | undefined;
+export type Present<T> = Exclude<T, null | undefined>;

tsconfig.json

@@ -1,14 +1,17 @@
 {
   "compilerOptions": {
     "declaration": true,
+    "declarationDir": "./dist",
     "outDir": "./dist",
     "module": "ESNext",
     "target": "ESNext",
     "lib": ["ES2023"],
     "moduleResolution": "node",
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "strictNullChecks": true,
   },
   "include": ["src"],
   "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]