@profidev/pleiades 1.7.0

package/dist/blocks/is-letter.d.ts

@@ -0,0 +1,12 @@
+export declare const LETTER_REGEX: RegExp;
+/** Checks if the provided character is a letter in the alphabet.
+ *
+ * @param char
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * isLetter('a');
+ * ```
+ */
+export declare function isLetter(char: string): boolean;

package/dist/blocks/is-letter.js

@@ -0,0 +1,20 @@
+/*
+    Installed from @ieedan/std
+*/
+export const LETTER_REGEX = new RegExp(/[a-zA-Z]/);
+/** Checks if the provided character is a letter in the alphabet.
+ *
+ * @param char
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * isLetter('a');
+ * ```
+ */
+export function isLetter(char) {
+    if (char.length > 1) {
+        throw new Error(`You probably only meant to pass a character to this function. Instead you gave ${char}`);
+    }
+    return LETTER_REGEX.test(char);
+}

package/dist/blocks/is-mac.svelte.d.ts

@@ -0,0 +1,6 @@
+/** Attempts to determine if a user is on a Mac using `navigator.userAgent`. */
+export declare const isMac: boolean;
+/** `⌘` for mac or `Ctrl` for windows */
+export declare const cmdOrCtrl: string;
+/** `⌥` for mac or `Alt` for windows */
+export declare const optionOrAlt: string;

package/dist/blocks/is-mac.svelte.js

@@ -0,0 +1,6 @@
+/** Attempts to determine if a user is on a Mac using `navigator.userAgent`. */
+export const isMac = navigator.userAgent.includes('Mac');
+/** `⌘` for mac or `Ctrl` for windows */
+export const cmdOrCtrl = isMac ? '⌘' : 'Ctrl';
+/** `⌥` for mac or `Alt` for windows */
+export const optionOrAlt = isMac ? '⌥' : 'Alt';

package/dist/blocks/is-number.d.ts

@@ -0,0 +1,18 @@
+/** Checks if provided value is actually a number.
+ *
+ * @param num value to check
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * isNumber("2"); // true
+ * isNumber("1.11"); // true
+ * isNumber("0xff"); // true
+ *
+ * isNumber("two"); // false
+ * isNumber({ two: 2 }); // false
+ * isNumber(Number.POSITIVE_INFINITY); // false
+ * ```
+ */
+export declare function isNumber(num: unknown): boolean;

package/dist/blocks/is-number.js

@@ -0,0 +1,27 @@
+/*
+    Installed from @ieedan/std
+*/
+/** Checks if provided value is actually a number.
+ *
+ * @param num value to check
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * isNumber("2"); // true
+ * isNumber("1.11"); // true
+ * isNumber("0xff"); // true
+ *
+ * isNumber("two"); // false
+ * isNumber({ two: 2 }); // false
+ * isNumber(Number.POSITIVE_INFINITY); // false
+ * ```
+ */
+export function isNumber(num) {
+    if (typeof num === 'number')
+        return num - num === 0;
+    if (typeof num === 'string' && num.trim() !== '')
+        return Number.isFinite(+num);
+    return false;
+}

package/dist/blocks/result.d.ts

@@ -0,0 +1,614 @@
+/** This is just a helper type used only within this file */
+type _Result<T, E> = {
+    ok: true;
+    val: T;
+} | {
+    ok: false;
+    err: E;
+};
+/** Result allows you to show to a consumer that a function might throw and force them to handle it.
+ *
+ *  `T` Value type
+ *
+ *  `E` Error type
+ *
+ * ## Usage
+ *
+ * ```ts
+ * function functionThatMightFail(): Result<T, E>;
+ * ```
+ *
+ * ## Usage
+ *
+ * ```ts
+ * const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");
+ *
+ * const result = functionThatMightFail();
+ *
+ * console.log(result.unwrap()); // "Hello, World!"
+ * ```
+ */
+declare class Result<T, E> {
+    private readonly _result;
+    constructor(result: _Result<T, E>);
+    /** Allows you to run callbacks based on the result.
+     *
+     * @param success callback to be run when result is success
+     * @param failure callback to be run when result is failure
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.match(
+     * 	(val) => val,
+     * 	() => {
+     * 		throw new Error('oops!')
+     * 	}
+     * );
+     * ```
+     *
+     * ## Usage
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const val = result.match(
+     * 	(val) => val,
+     * 	() => {
+     * 		throw new Error('oops!')
+     * 	}
+     * );
+     *
+     * console.log(val); // "Hello, World!"
+     * ```
+     */
+    match<A, B = A>(success: (val: T) => A, failure: (err: E) => B): A | B;
+    /** Maps `Result<T, E>` to `Result<A, E>` using the passed mapping function
+     *
+     * @param fn Mapping function
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.map((val) => val.length);
+     * ```
+     *
+     * ## Usage
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello, World!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const hello = result.map((val) => val.slice(0, 5));
+     *
+     * console.log(hello.unwrap()); // "Hello"
+     * ```
+     */
+    map<A>(fn: (val: T) => A): Result<A, E>;
+    /** In the `Ok` case returns the mapped value using the function else returns `defaultVal`
+     *
+     * @param defaultVal Value to be returned when `Err`
+     * @param fn Mapping function to map in case of `Ok`
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.mapOr(1, (val) => val.length);
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const length = result.mapOr(1, (val) => val.length);
+     *
+     * console.log(length); // 3
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const length = result.mapOr(1, (val) => val.length);
+     *
+     * console.log(length); // 1
+     * ```
+     */
+    mapOr<A>(defaultVal: A, fn: (val: T) => A): A;
+    /** In the `Ok` case returns the mapped value using `fn` else returns value of `def`
+     *
+     * @param def Mapping function called when `Err`
+     * @param fn Mapping function called when `Ok`
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.mapOrElse(() => 1, (val) => val.length);
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const length = result.mapOrElse(() => 1, (val) => val.length);
+     *
+     * console.log(length); // 3
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const length = result.mapOr(() => 1, (val) => val.length);
+     *
+     * console.log(length); // 1
+     * ```
+     */
+    mapOrElse<A>(def: (err: E) => A, fn: (val: T) => A): A;
+    /** Maps `Result<T, E>` to `Result<T, A>` using the passed mapping function
+     *
+     * @param fn Mapping function
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.mapErr((err) => getCodeMsg(err));
+     * ```
+     *
+     * ## Usage
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err(10);
+     *
+     * const result = functionThatMightFail();
+     *
+     * const message = result.mapErr(() => "Error");
+     *
+     * console.log(message); // "Error"
+     * ```
+     */
+    mapErr<A>(fn: (err: E) => A): Result<T, A>;
+    /** In the `Err` case returns the mapped value using the function else returns `defaultVal`
+     *
+     * @param defaultVal Value to be returned when `Ok`
+     * @param fn Mapping function to map in case of `Err`
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.mapErrOr("Should've been error", (err) => getCodeMsg(err));
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const message = result.mapErrOr("Should've been error", () => "Error");
+     *
+     * console.log(message); // "Should've been error"
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err(10);
+     *
+     * const result = functionThatMightFail();
+     *
+     * const message = result.mapErrOr("Should've been error", () => "Error");
+     *
+     * console.log(message); // "Error"
+     * ```
+     */
+    mapErrOr<A>(defaultVal: A, fn: (err: E) => A): A;
+    /** In the `Err` case returns the mapped value using the function else returns value of `def`
+     *
+     * @param def Mapping function called when `Ok`
+     * @param fn Mapping function called when `Err`
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.mapErrOrElse(() => "Value", (_) => "Error!");
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("foo");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const length = result.mapErrOrElse(() => 1, (val) => val.length);
+     *
+     * console.log(length); // 1
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * const length = result.mapOr(() => 1, (val) => val.length);
+     *
+     * console.log(length); // 4
+     * ```
+     */
+    mapErrOrElse<A>(def: (val: T) => A, fn: (err: E) => A): A;
+    /** Returns true if result is `Ok`
+     *
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.isOk();
+     * ```
+     */
+    isOk(): boolean;
+    /** Returns true if result is `Err`
+     *
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.isErr();
+     * ```
+     */
+    isErr(): boolean;
+    /** Tries to return value if value is `Err` throws generic error message.
+     *
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.unwrap();
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrap()); // "Hello!"
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * result.unwrap(); // Error: Attempted to call `.unwrap()` on a non `Ok` value.
+     * ```
+     */
+    unwrap(): T;
+    /** Tries to return err if value is `Ok` throws generic error message.
+     *
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.unwrapErr();
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * result.unwrapErr(); // Error: Attempted to call `.unwrapErr()` on a non `Err` value.
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapErr()); // "oops!"
+     * ```
+     */
+    unwrapErr(): E;
+    /** Tries to unwrap the value if value is `Err` returns `defaultVal`
+     *
+     * @param defaultVal Value to be returned if `Err`
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.unwrapOr(7);
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapOr("Yellow!")); // "Hello!"
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapOr("Yellow!")); // "Yellow!"
+     * ```
+     */
+    unwrapOr(defaultVal: T): T;
+    /** Tries to unwrap the error if vale is `Ok` returns `defaultVal`
+     *
+     * @param defaultVal
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.unwrapErrOr("Error");
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapErrOr("Yellow!")); // "Yellow!"
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapErrOr("Yellow!")); // "oops!"
+     * ```
+     */
+    unwrapErrOr(defaultVal: E): E;
+    /** Tries to return the value if value is `Err` calls `fn`
+     *
+     * @param fn Function called if `Err`
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.unwrapOrElse(() => "Hello!");
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapOrElse(() => "oops!")); // "Hello!"
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapOrElse(() => "Hello!")); // "Hello!"
+     * ```
+     *
+     */
+    unwrapOrElse(fn: (err: E) => T): T;
+    /** Tries to return the error if value is `Ok` calls `fn`
+     *
+     * @param fn Function called if `Ok`
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.unwrapErrOrElse(() => "Error!");
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapErrOrElse(() => "oops!")); // "oops!"
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.unwrapErrOrElse(() => "Hello!")); // "oops!"
+     * ```
+     *
+     */
+    unwrapErrOrElse(fn: (val: T) => E): E;
+    /** Tries to return value if value is `Err` throws custom error message.
+     *
+     * @param message Message to show when value is `Err`
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.expect("Custom message");
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.expect("I failed!")); // "Hello!"
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * result.expect("I failed!"); // Error: I failed!
+     * ```
+     */
+    expect(message: string): T;
+    /** Tries to return error value if value is `Ok` throws custom error message
+     *
+     * @param message
+     * @returns
+     *
+     * ## Usage
+     *
+     * ```ts
+     * result.expectErr("Custom message");
+     * ```
+     *
+     * ## Usage
+     *
+     * ### When `Ok`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Ok("Hello!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.expectErr("I failed!")); // Error: I failed!
+     * ```
+     *
+     * ### When `Err`
+     *
+     * ```ts
+     * const functionThatMightFail = (): Result<string, string> => Err("oops!");
+     *
+     * const result = functionThatMightFail();
+     *
+     * console.log(result.expectErr("I failed!")); // "oops!"
+     * ```
+     */
+    expectErr(message: string): E;
+}
+/** Returns a new `Ok` result type with the provided value
+ *
+ * @param val Value of the result
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * Ok(true);
+ * ```
+ *
+ * ## Usage
+ *
+ * ```ts
+ * const functionThatCanFail = (condition) => {
+ * 	if (condition) {
+ * 		Ok("Success")
+ * 	}
+ *
+ * 	return Err("Failure");
+ * }
+ * ```
+ */
+export declare function Ok<T>(val: T): Result<T, never>;
+/** Returns a new `Err` result type with the provided error
+ *
+ * @param err Error of the result
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * Err("I failed!");
+ * ```
+ *
+ * ## Usage
+ *
+ * ```ts
+ * const functionThatCanFail = (condition) => {
+ * 	if (condition) {
+ * 		Ok("Success")
+ * 	}
+ *
+ * 	return Err("Failure");
+ * }
+ * ```
+ */
+export declare function Err<E>(err: E): Result<never, E>;
+export type { Result };