@profidev/pleiades 1.7.0

package/dist/util/casing.js

@@ -0,0 +1,286 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+/*
+    Installed from @ieedan/std
+*/
+import { isLetter } from './is-letter';
+/** Converts a `camelCase` string to a `snake_case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('helloWorld'); // hello_world
+ * ```
+ */
+export function camelToSnake(str) {
+    let newStr = '';
+    for (let i = 0; i < str.length; i++) {
+        // is uppercase letter
+        if (isLetter(str[i]) && str[i].toUpperCase() === str[i]) {
+            let l = i;
+            while (l < str.length &&
+                isLetter(str[l]) &&
+                str[l].toUpperCase() === str[l]) {
+                l++;
+            }
+            newStr += `${str.slice(i, l - 1).toLocaleLowerCase()}_${str[l - 1].toLocaleLowerCase()}`;
+            i = l - 1;
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}
+/** Converts a `PascalCase` string to a `snake_case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('HelloWorld'); // hello_world
+ * ```
+ */
+export function pascalToSnake(str) {
+    let newStr = '';
+    let firstLetter;
+    for (let i = 0; i < str.length; i++) {
+        if (firstLetter === undefined && isLetter(str[i])) {
+            firstLetter = i;
+        }
+        // is uppercase letter (ignoring the first)
+        if (firstLetter !== undefined &&
+            i > firstLetter &&
+            isLetter(str[i]) &&
+            str[i].toUpperCase() === str[i]) {
+            let l = i;
+            while (l < str.length &&
+                isLetter(str[l]) &&
+                str[l].toUpperCase() === str[l]) {
+                l++;
+            }
+            newStr += `${str.slice(i, l - 1).toLocaleLowerCase()}_${str[l - 1].toLocaleLowerCase()}`;
+            i = l - 1;
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}
+/** Converts a `camelCase` string to a `kebab-case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('helloWorld'); // hello-world
+ * ```
+ */
+export function camelToKebab(str) {
+    let newStr = '';
+    for (let i = 0; i < str.length; i++) {
+        // is uppercase letter
+        if (i > 0 && isLetter(str[i]) && str[i].toUpperCase() === str[i]) {
+            let l = i;
+            while (l < str.length &&
+                isLetter(str[l]) &&
+                str[l].toUpperCase() === str[l]) {
+                l++;
+            }
+            newStr += `${str.slice(i, l - 1).toLocaleLowerCase()}-${str[l - 1].toLocaleLowerCase()}`;
+            i = l - 1;
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}
+/** Converts a `PascalCase` string to a `kebab-case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('HelloWorld'); // hello-world
+ * ```
+ */
+export function pascalToKebab(str) {
+    let newStr = '';
+    for (let i = 0; i < str.length; i++) {
+        // is uppercase letter (ignoring the first)
+        if (i > 0 && isLetter(str[i]) && str[i].toUpperCase() === str[i]) {
+            let l = i;
+            while (l < str.length &&
+                isLetter(str[l]) &&
+                str[l].toUpperCase() === str[l]) {
+                l++;
+            }
+            newStr += `${str.slice(i, l - 1).toLocaleLowerCase()}-${str[l - 1].toLocaleLowerCase()}`;
+            i = l - 1;
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}
+/** Converts a `camelCase` string to a `PascalCase` string (makes first letter lowercase)
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToPascal('helloWorld'); // HelloWorld
+ * ```
+ */
+export function camelToPascal(str) {
+    return `${str[0].toLocaleUpperCase()}${str.slice(1)}`;
+}
+/** Converts a `PascalCase` string to a `camelCase` string (makes first letter uppercase)
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToPascal('HelloWorld'); // helloWorld
+ * ```
+ */
+export function pascalToCamel(str) {
+    return `${str[0].toLocaleLowerCase()}${str.slice(1)}`;
+}
+/** Converts a `snake_case` string to a `PascalCase` string
+ *
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * snakeToPascal('hello_world'); // HelloWorld
+ * snakeToPascal('HELLO_WORLD'); // HelloWorld
+ * ```
+ */
+export function snakeToPascal(str) {
+    let newStr = '';
+    let firstLetter = true;
+    for (let i = 0; i < str.length; i++) {
+        // capitalize first letter
+        if (firstLetter && isLetter(str[i])) {
+            firstLetter = false;
+            newStr += str[i].toUpperCase();
+            continue;
+        }
+        // capitalize first after a _ (ignoring the first)
+        if (!firstLetter && str[i] === '_') {
+            i++;
+            if (i <= str.length - 1) {
+                newStr += str[i].toUpperCase();
+            }
+            else {
+                newStr += '_';
+            }
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}
+/** Converts a `snake_case` string to a `camelCase` string
+ *
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * snakeToCamel('hello_world'); // helloWorld
+ * snakeToCamel('HELLO_WORLD'); // helloWorld
+ * ```
+ */
+export function snakeToCamel(str) {
+    let newStr = '';
+    let firstLetter = true;
+    for (let i = 0; i < str.length; i++) {
+        // capitalize first letter
+        if (firstLetter && isLetter(str[i])) {
+            firstLetter = false;
+            newStr += str[i].toLowerCase();
+            continue;
+        }
+        // capitalize first after a _ (ignoring the first)
+        if (!firstLetter && str[i] === '_') {
+            i++;
+            if (i <= str.length - 1) {
+                newStr += str[i].toUpperCase();
+            }
+            else {
+                newStr += '_';
+            }
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}
+/** Converts a `kebab-case` string to a `PascalCase` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * kebabToPascal('hello-world'); // HelloWorld
+ * ```
+ */
+export function kebabToPascal(str) {
+    let newStr = '';
+    for (let i = 0; i < str.length; i++) {
+        // capitalize first
+        if (i === 0) {
+            newStr += str[i].toUpperCase();
+            continue;
+        }
+        // capitalize first after a -
+        if (str[i] === '-') {
+            i++;
+            if (i <= str.length - 1) {
+                newStr += str[i].toUpperCase();
+            }
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}
+/** Converts a `kebab-case` string to a `camelCase` string
+ *
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * kebabToCamel('hello-world'); // helloWorld
+ * ```
+ */
+export function kebabToCamel(str) {
+    let newStr = '';
+    for (let i = 0; i < str.length; i++) {
+        // capitalize first after a -
+        if (str[i] === '-') {
+            i++;
+            if (i <= str.length - 1) {
+                newStr += str[i].toUpperCase();
+            }
+            continue;
+        }
+        newStr += str[i].toLocaleLowerCase();
+    }
+    return newStr;
+}

package/dist/util/convert.svelte.d.ts

@@ -0,0 +1,2 @@
+export declare const arrayBufferToBase64: (buffer: ArrayBuffer) => string;
+export declare const base64ToArrayBuffer: (base64: string) => ArrayBuffer;

package/dist/util/convert.svelte.js

@@ -0,0 +1,18 @@
+export const arrayBufferToBase64 = (buffer) => {
+    let byteArray = new Uint8Array(buffer);
+    let string = '';
+    byteArray.forEach((b) => {
+        string += String.fromCharCode(b);
+    });
+    return btoa(string);
+};
+export const base64ToArrayBuffer = (base64) => {
+    let string = atob(base64);
+    let len = string.length;
+    let buffer = new ArrayBuffer(len);
+    let bytes = new Uint8Array(buffer);
+    for (let i = 0; i < len; i++) {
+        bytes[i] = string.charCodeAt(i);
+    }
+    return buffer;
+};

package/dist/util/interval.svelte.d.ts

@@ -0,0 +1,5 @@
+export declare const interval: <T>(update: () => T, timeout: number) => {
+    readonly value: T;
+};
+export declare const wait_for: (condition: () => boolean, intervalTime?: number, max?: number) => Promise<boolean>;
+export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/util/interval.svelte.js

@@ -0,0 +1,74 @@
+import { tick, untrack } from 'svelte';
+const createKeyedWatcher = () => {
+    let watchers = new Map();
+    return {
+        watch(setup) {
+            if ($effect.tracking()) {
+                $effect(() => {
+                    let entry = watchers.get(setup);
+                    if (!entry) {
+                        const cleanup = untrack(setup);
+                        entry = [0, cleanup];
+                        watchers.set(setup, entry);
+                    }
+                    entry[0]++;
+                    return () => {
+                        tick().then(() => {
+                            entry[0]--;
+                            if (entry[0] === 0) {
+                                entry[1]?.();
+                                watchers.delete(setup);
+                            }
+                        });
+                    };
+                });
+            }
+        }
+    };
+};
+export const interval = (update, timeout) => {
+    let value = $state(update());
+    const setup = () => {
+        const id = setInterval(() => {
+            value = update();
+        }, timeout);
+        return () => clearInterval(id);
+    };
+    const watcher = createKeyedWatcher();
+    return {
+        get value() {
+            watcher.watch(setup);
+            return value;
+        }
+    };
+};
+export const wait_for = (condition, intervalTime = 100, max) => {
+    return new Promise((resolve) => {
+        if (condition()) {
+            resolve(true);
+            return;
+        }
+        let timeout = undefined;
+        const interval = setInterval(() => {
+            if (condition()) {
+                clearInterval(interval);
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                resolve(true);
+            }
+        }, intervalTime);
+        if (max) {
+            timeout = setTimeout(() => {
+                clearInterval(interval);
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                resolve(false);
+            }, max);
+        }
+    });
+};
+export const sleep = (ms) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+};

package/dist/util/ipv4-address.d.ts

@@ -0,0 +1,48 @@
+import { type Result } from './result';
+export type Octets = [number, number, number, number];
+export type IPv4Address = Octets | `${number}.${number}.${number}.${number}` | `${number} ${number} ${number} ${number}` | `${number}_${number}_${number}_${number}`;
+export type ParseError = {
+    octet?: number;
+    message: string;
+};
+/** Parses the ip address from a string in the format of `0.0.0.0` or `0 0 0 0` or `0_0_0_0` into an array of octets
+ *
+ * @param address
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * parse("192.168.100.10").unwrap(); // [192, 168, 100, 10]
+ * ```
+ */
+export declare function parse(address: string): Result<Octets, ParseError>;
+/** Validates the provided address
+ *
+ * @param address
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * validate("192.168.100.10"); // true
+ * validate([192, 168, 100, 10]); // true
+ *
+ * validate("192.168.100.256"); // false
+ * validate([192, 168, 100, 256]); // false
+ * ```
+ */
+export declare function validate(address: IPv4Address): boolean;
+/** Formats the provided address to a string with the provided separator
+ *
+ * @param address
+ * @param separator @default "."
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * formatToString([192, 168, 100, 10]); // "192.168.100.10"
+ * ```
+ */
+export declare function formatToString(address: IPv4Address, separator?: '.' | '_' | ' '): Result<string, string>;

package/dist/util/ipv4-address.js

@@ -0,0 +1,85 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+/*
+    Installed from @ieedan/std
+*/
+import { isNumber } from './is-number';
+import { Err, Ok } from './result';
+/** Parses the ip address from a string in the format of `0.0.0.0` or `0 0 0 0` or `0_0_0_0` into an array of octets
+ *
+ * @param address
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * parse("192.168.100.10").unwrap(); // [192, 168, 100, 10]
+ * ```
+ */
+export function parse(address) {
+    let newAddress = address.trim();
+    newAddress = newAddress.replaceAll(' ', '.');
+    newAddress = newAddress.replaceAll('_', '.');
+    const octets = newAddress.split('.');
+    if (octets.length !== 4)
+        return Err({
+            message: `'${address}' is invalid as it doesn't contain 4 octets.`
+        });
+    const final = [0, 0, 0, 0];
+    for (let i = 0; i < octets.length; i++) {
+        const octet = octets[i];
+        if (!isNumber(octet))
+            return Err({ octet: i + 1, message: `'${octet}' is not a number.` });
+        const num = Number.parseInt(octet);
+        if (num < 0 || num > 255)
+            return Err({ octet: i + 1, message: `'${octet}' is out of range.` });
+        final[i] = num;
+    }
+    return Ok(final);
+}
+/** Validates the provided address
+ *
+ * @param address
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * validate("192.168.100.10"); // true
+ * validate([192, 168, 100, 10]); // true
+ *
+ * validate("192.168.100.256"); // false
+ * validate([192, 168, 100, 256]); // false
+ * ```
+ */
+export function validate(address) {
+    if (typeof address === 'string')
+        return parse(address).isOk();
+    for (let i = 0; i < address.length; i++) {
+        const octet = address[i];
+        if (octet < 0 || octet > 255)
+            return false;
+    }
+    return true;
+}
+/** Formats the provided address to a string with the provided separator
+ *
+ * @param address
+ * @param separator @default "."
+ * @returns
+ *
+ * ## Usage
+ *
+ * ```ts
+ * formatToString([192, 168, 100, 10]); // "192.168.100.10"
+ * ```
+ */
+export function formatToString(address, separator = '.') {
+    if (Array.isArray(address))
+        return Ok(address.join(separator));
+    const parsed = parse(address);
+    if (parsed.isErr())
+        return Err(parsed.unwrapErr().message);
+    return formatToString(parsed.unwrap(), separator);
+}

package/dist/util/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/util/is-letter.js

@@ -0,0 +1,23 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+/*
+    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/util/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/util/is-number.js

@@ -0,0 +1,30 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+/*
+    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/util/other.svelte.d.ts

@@ -0,0 +1,2 @@
+export declare const isUrl: (url: string) => boolean;
+export declare const deepCopy: <T>(object: T) => T;

package/dist/util/other.svelte.js

@@ -0,0 +1,12 @@
+export const isUrl = (url) => {
+    try {
+        let _ = new URL(url);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+};
+export const deepCopy = (object) => {
+    return JSON.parse(JSON.stringify(object));
+};