@terrygonguet/utils 0.0.1 → 0.0.3

package/package.json

@@ -1,20 +1,35 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.0.1",
+	"version": "0.0.3",
 	"type": "module",
 	"scripts": {
 		"dev": "vite",
 		"build": "tsc && vite build",
-		"preview": "vite preview"
+		"test": "vitest test --ui --watch --update",
+		"coverage": "vitest run --coverage"
 	},
 	"devDependencies": {
+		"@vitest/ui": "^0.32.0",
+		"prettier": "^2.8.8",
 		"typescript": "^5.0.2",
-		"vite": "^4.3.9"
+		"vite": "^4.3.9",
+		"vitest": "^0.32.0"
 	},
 	"exports": {
 		".": {
-			"types": "./dist/main.js",
-			"import": "./types/main.d.ts"
+			"types": "./types/main.js",
+			"import": "./dist/main.d.ts"
+		},
+		"./async": {
+			"types": "./types/async.js",
+			"import": "./dist/async.d.ts"
+		},
+		"./functional": {
+			"types": "./types/functional/index.d.ts",
+			"import": "./dist/functional.js"
 		}
+	},
+	"dependencies": {
+		"just-compose": "^2.3.0"
 	}
 }

package/src/async.ts

@@ -0,0 +1,3 @@
+export function wait(ms: number): Promise<void> {
+	return new Promise(resolve => setTimeout(resolve, ms))
+}

package/src/functional/index.ts

@@ -0,0 +1,7 @@
+export * from "./maybe.ts"
+export * from "./result.ts"
+export { default as compose } from "just-compose"
+
+export function identity<T>(value: T) {
+	return value
+}

package/src/functional/maybe.ts

@@ -0,0 +1,81 @@
+import { identity } from "./index.ts"
+
+interface API<T> {
+	isSome(this: Maybe<T>): this is Some<T>
+	isNone(this: Maybe<T>): this is None<T>
+	orDefault(this: Maybe<T>, defaultValue: T): T
+	map<U>(this: Maybe<T>, f: (value: T) => U): Maybe<U>
+	flatMap<U>(this: Maybe<T>, f: (value: T) => Maybe<U>): Maybe<U>
+	toJSON(this: Maybe<T>): Object
+}
+
+export type Some<T> = { value: T } & API<T>
+export type None<T> = API<T>
+export type Maybe<T> = Some<T> | None<T>
+
+const $_kind = "@terrygonguet/utils/functional/maybe"
+const $_variant_Some = "@terrygonguet/utils/functional/maybe/Some"
+const $_variant_None = "@terrygonguet/utils/functional/maybe/None"
+
+export function Some<T>(value: NonNullable<T>): Some<T> {
+	return Object.create(
+		{
+			isSome: () => true,
+			isNone: () => false,
+			orDefault(this: Some<T>) {
+				return this.value
+			},
+			map(this: Some<T>, f) {
+				return Some(f(this.value)!)
+			},
+			flatMap(this: Some<T>, f) {
+				return f(this.value)
+			},
+			toJSON(this: Some<T>) {
+				return { $_kind, $_variant: $_variant_Some, value: this.value }
+			},
+		} as API<T>,
+		{
+			$_kind: { value: $_kind, enumerable: false, writable: false },
+			$_variant: { value: $_variant_Some, enumerable: false, writable: false },
+			value: { value, writable: false },
+		},
+	)
+}
+
+export const None: None<any> = Object.create(
+	{
+		isSome: () => false,
+		isNone: () => true,
+		orDefault: identity,
+		map: () => None,
+		flatMap: () => None,
+		toJSON: () => ({ $_kind, $_variant: $_variant_None }),
+	} as API<any>,
+	{
+		$_kind: { value: $_kind, enumerable: false, writable: false },
+		$_variant: { value: $_variant_None, enumerable: false, writable: false },
+	},
+)
+
+export const Maybe = {
+	Some,
+	None,
+	from<T>(value: T | undefined | null): Maybe<T> {
+		switch (value) {
+			case null:
+			case undefined:
+				return None
+			default:
+				return Some(value!)
+		}
+	},
+	JSONReviver(_key: string, value: any) {
+		if (value?.$_kind == $_kind) {
+			const $_variant = value?.$_variant
+			if ($_variant == $_variant_Some) return Some<unknown>(value?.value)
+			else if ($_variant == $_variant_None) return None
+			else return value
+		} else return value
+	},
+}

package/src/functional/result.ts

@@ -0,0 +1,102 @@
+import { identity } from "./index.ts"
+
+interface API<S, F> {
+	isSuccess(this: Result<S, F>): this is Success<S, F>
+	isFailure(this: Result<S, F>): this is Failure<S, F>
+	map<S2>(this: Result<S, F>, f: (value: S) => S2): Result<S2, F>
+	flatMap<S2, F2>(this: Result<S, F>, f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>
+	toJSON(this: Result<S, F>): Object
+}
+
+export type Success<S, F> = { value: S } & API<S, F>
+export type Failure<S, F> = { reason: F } & API<S, F>
+export type Result<S, F> = Success<S, F> | Failure<S, F>
+
+const $_kind = "@terrygonguet/utils/functional/result"
+const $_variant_Success = "@terrygonguet/utils/functional/result/Success"
+const $_variant_Failure = "@terrygonguet/utils/functional/result/Failure"
+
+export function Success<S, F>(value: S): Success<S, F> {
+	return Object.create(
+		{
+			isSuccess: () => true,
+			isFailure: () => false,
+			map<S2>(this: Success<S, F>, f: (value: S) => S2) {
+				return Success(f(this.value))
+			},
+			flatMap<S2, F2>(this: Success<S, F>, f: (value: S) => Result<S2, F2>) {
+				return f(this.value)
+			},
+			toJSON(this: Success<S, F>) {
+				return { $_kind, $_variant: $_variant_Success, value: this.value }
+			},
+		} as API<S, F>,
+		{
+			$_kind: { value: $_kind, enumerable: false, writable: false },
+			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
+			value: { value, writable: false },
+		},
+	)
+}
+
+export function Failure<S, F>(reason: F): Failure<S, F> {
+	return Object.create(
+		{
+			isSuccess: () => false,
+			isFailure: () => true,
+			map<S2>(this: Failure<S, F>) {
+				return this as unknown as Result<S2, F>
+			},
+			flatMap<S2, F2>(this: Failure<S, F>) {
+				return this as unknown as Result<S2, F | F2>
+			},
+			toJSON(this: Failure<S, F>) {
+				return { $_kind, $_variant: $_variant_Failure, reason: this.reason }
+			},
+		} as API<S, F>,
+		{
+			$_kind: { value: $_kind, enumerable: false, writable: false },
+			$_variant: { value: $_variant_Success, enumerable: false, writable: false },
+			reason: { value: reason, writable: false },
+		},
+	)
+}
+
+export const Result = {
+	Success,
+	Failure,
+	try<S, F>(tryFn: () => S) {
+		return new TryCatch<S, F>(tryFn)
+	},
+	JSONReviver(_key: string, value: any) {
+		if (value?.$_kind == $_kind) {
+			const $_variant = value?.$_variant
+			if ($_variant == $_variant_Success) return Success<unknown, unknown>(value?.value)
+			else if ($_variant == $_variant_Failure) return Failure<unknown, unknown>(value?.reason)
+			else return value
+		} else return value
+	},
+}
+
+export class TryCatch<S, F> {
+	tryFn: () => S
+	catchFn: (err: unknown) => F
+
+	constructor(tryFn: () => S) {
+		this.tryFn = tryFn
+		this.catchFn = identity as any
+	}
+
+	catch(catchFn: (err: unknown) => F) {
+		this.catchFn = catchFn
+		return this
+	}
+
+	exec(): Result<S, F> {
+		try {
+			return Success<S, F>(this.tryFn())
+		} catch (error) {
+			return Failure<S, F>(this.catchFn(error))
+		}
+	}
+}

package/src/main.ts

@@ -1,3 +1,25 @@
+/**
+ * Behaviour is undefined when max < min
+ */
 export function clamp(value: number, min: number, max: number) {
 	return Math.min(Math.max(value, min), max)
-}
+}
+
+type JSONReviver = (key: string, value: any) => any
+
+export function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver) {
+	try {
+		return JSON.parse(str, reviver)
+	} catch (_) {
+		return defaultValue
+	}
+}
+
+export function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver {
+	return function (key, value) {
+		for (const reviver of revivers) {
+			value = reviver(key, value)
+		}
+		return value
+	}
+}

package/tsconfig.json

@@ -3,12 +3,13 @@
 		"target": "ES2020",
 		"useDefineForClassFields": true,
 		"module": "ESNext",
-		"lib": ["ES2020"],
+		"lib": ["ES2020", "DOM", "DOM.Iterable"],
 		"skipLibCheck": true,
 
 		/* Bundler mode */
 		"moduleResolution": "node16",
 		"allowImportingTsExtensions": true,
+		"allowSyntheticDefaultImports": true,
 		"resolveJsonModule": true,
 		"isolatedModules": true,
 		"declaration": true,
@@ -18,8 +19,7 @@
 		/* Linting */
 		"strict": true,
 		"noUnusedLocals": true,
-		"noUnusedParameters": true,
-		"noFallthroughCasesInSwitch": true
+		"noUnusedParameters": true
 	},
 	"include": ["src"]
 }

package/types/async.d.ts

@@ -0,0 +1 @@
+export declare function wait(ms: number): Promise<void>;

package/types/functional/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./maybe.ts";
+export * from "./result.ts";
+export { default as compose } from "just-compose";
+export declare function identity<T>(value: T): T;

package/types/functional/maybe.d.ts

@@ -0,0 +1,22 @@
+interface API<T> {
+    isSome(this: Maybe<T>): this is Some<T>;
+    isNone(this: Maybe<T>): this is None<T>;
+    orDefault(this: Maybe<T>, defaultValue: T): T;
+    map<U>(this: Maybe<T>, f: (value: T) => U): Maybe<U>;
+    flatMap<U>(this: Maybe<T>, f: (value: T) => Maybe<U>): Maybe<U>;
+    toJSON(this: Maybe<T>): Object;
+}
+export type Some<T> = {
+    value: T;
+} & API<T>;
+export type None<T> = API<T>;
+export type Maybe<T> = Some<T> | None<T>;
+export declare function Some<T>(value: NonNullable<T>): Some<T>;
+export declare const None: None<any>;
+export declare const Maybe: {
+    Some: typeof Some;
+    None: None<any>;
+    from<T>(value: T | null | undefined): Maybe<T>;
+    JSONReviver(_key: string, value: any): any;
+};
+export {};

package/types/functional/result.d.ts

@@ -0,0 +1,30 @@
+interface API<S, F> {
+    isSuccess(this: Result<S, F>): this is Success<S, F>;
+    isFailure(this: Result<S, F>): this is Failure<S, F>;
+    map<S2>(this: Result<S, F>, f: (value: S) => S2): Result<S2, F>;
+    flatMap<S2, F2>(this: Result<S, F>, f: (value: S) => Result<S2, F | F2>): Result<S2, F | F2>;
+    toJSON(this: Result<S, F>): Object;
+}
+export type Success<S, F> = {
+    value: S;
+} & API<S, F>;
+export type Failure<S, F> = {
+    reason: F;
+} & API<S, F>;
+export type Result<S, F> = Success<S, F> | Failure<S, F>;
+export declare function Success<S, F>(value: S): Success<S, F>;
+export declare function Failure<S, F>(reason: F): Failure<S, F>;
+export declare const Result: {
+    Success: typeof Success;
+    Failure: typeof Failure;
+    try<S, F>(tryFn: () => S): TryCatch<S, F>;
+    JSONReviver(_key: string, value: any): any;
+};
+export declare class TryCatch<S, F> {
+    tryFn: () => S;
+    catchFn: (err: unknown) => F;
+    constructor(tryFn: () => S);
+    catch(catchFn: (err: unknown) => F): this;
+    exec(): Result<S, F>;
+}
+export {};

package/types/main.d.ts

@@ -1 +1,8 @@
+/**
+ * Behaviour is undefined when max < min
+ */
 export declare function clamp(value: number, min: number, max: number): number;
+type JSONReviver = (key: string, value: any) => any;
+export declare function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver): any;
+export declare function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver;
+export {};

package/vite.config.js

@@ -1,13 +1,15 @@
-import { resolve } from "path"
-import { defineConfig } from "vite"
-
-export default defineConfig({
-	build: {
-		lib: {
-			formats: ["es"],
-			entry: {
-				main: resolve(__dirname, "src/main.ts"),
-			},
-		},
-	},
-})
+import { resolve } from "path"
+import { defineConfig } from "vite"
+
+export default defineConfig({
+	build: {
+		lib: {
+			formats: ["es"],
+			entry: {
+				main: resolve(__dirname, "src/main.ts"),
+				async: resolve(__dirname, "src/async.ts"),
+				functional: resolve(__dirname, "src/functional/index.ts"),
+			},
+		},
+	},
+})