@profidev/pleiades 1.7.0

package/dist/blocks/active.svelte.js

@@ -0,0 +1,65 @@
+import { page } from '$app/state';
+import { untrack } from 'svelte';
+import { createAttachmentKey } from 'svelte/attachments';
+import { SvelteURL } from 'svelte/reactivity';
+/** Sets the `data-active` attribute on an `<a/>` tag based on its 'active' state.
+ *
+ * @param node
+ * @param opts
+ *
+ * ## Usage
+ * ```svelte
+ * <a href="/" use:active>Route</a>
+ * ```
+ */
+export function active(node, opts = {}) {
+    checkIsActive(node.href, { ...opts, url: page.url }).toString();
+    $effect(() => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        page.url;
+        untrack(() => {
+            node.setAttribute('data-active', checkIsActive(node.href, { ...opts, url: page.url }).toString());
+        });
+    });
+}
+/** Sets the `data-active` attribute on an `<a/>` tag based on its 'active' state.
+ *
+ * @param opts
+ * @returns
+ *
+ * ## Usage
+ * ```svelte
+ * <a href="/" {...attachActive()}>Route</a>
+ * ```
+ */
+export function attachActive(opts = {}) {
+    return {
+        [createAttachmentKey()]: (node) => active(node, opts)
+    };
+}
+export const checkIsActive = (nodeHref, { activeForSubdirectories, url, isHash, isSearch }) => {
+    let href = new SvelteURL(nodeHref).pathname;
+    if (isHash) {
+        href = new SvelteURL(nodeHref).hash;
+    }
+    let searchParamName = undefined;
+    let searchParamValue = undefined;
+    if (isSearch) {
+        const tempUrl = new SvelteURL(nodeHref);
+        for (const [key, value] of tempUrl.searchParams.entries()) {
+            searchParamName = key;
+            searchParamValue = value;
+        }
+        href = new SvelteURL(nodeHref).search;
+    }
+    const samePath = href === url.pathname;
+    const isParentRoute = (activeForSubdirectories == undefined || activeForSubdirectories) &&
+        url.pathname.startsWith(href ?? '');
+    const isHashRoute = isHash == true &&
+        (url.hash == href || ((href == '#' || href == '#/') && url.hash == ''));
+    const isSearchRoute = isSearch === true &&
+        searchParamName !== undefined &&
+        searchParamValue !== undefined &&
+        (url.searchParams.get(searchParamName) ?? '/') === searchParamValue;
+    return samePath || isParentRoute || isHashRoute || isSearchRoute;
+};

package/dist/blocks/button.svelte

@@ -0,0 +1,86 @@
+<script lang="ts" module>
+  import type { MouseEventHandler } from 'svelte/elements';
+
+  export type ButtonProps = ButtonPrimitiveProps & {
+    loading?: boolean;
+    onClickPromise?: (
+      e:
+        | Parameters<MouseEventHandler<HTMLButtonElement>>[0]
+        | Parameters<MouseEventHandler<HTMLAnchorElement>>[0]
+    ) => Promise<void>;
+  };
+
+  export type Size = 'default' | 'xs' | 'sm' | 'lg';
+
+  /**
+   * Map sizes to their icon/normal size variant
+   */
+  export const sizeMap = {
+    default: {
+      icon: 'icon',
+      normal: 'default'
+    },
+    xs: {
+      icon: 'icon-xs',
+      normal: 'xs'
+    },
+    sm: {
+      icon: 'icon-sm',
+      normal: 'sm'
+    },
+    lg: {
+      icon: 'icon-lg',
+      normal: 'lg'
+    }
+  } as const;
+
+  export {
+    type ButtonSize,
+    type ButtonVariant
+  } from '../components/ui-extra/button';
+</script>
+
+<script lang="ts">
+  import {
+    Button,
+    type ButtonProps as ButtonPrimitiveProps
+  } from '../components/ui-extra/button';
+  import { Spinner } from '../components/ui-extra/spinner';
+
+  let {
+    ref = $bindable(null),
+    loading: loadingProp = false,
+    onClickPromise,
+    onclick,
+    disabled,
+    children,
+    ...restProps
+  }: ButtonProps = $props();
+
+  let pending = $state(false);
+
+  const loading = $derived(loadingProp || pending);
+</script>
+
+<Button
+  bind:ref
+  disabled={loading || disabled}
+  onclick={async (e) => {
+    onclick?.(e as never);
+
+    if (onClickPromise) {
+      pending = true;
+      try {
+        await onClickPromise(e);
+      } finally {
+        pending = false;
+      }
+    }
+  }}
+  {...restProps}
+>
+  {#if loading}
+    <Spinner data-icon="inline-start" />
+  {/if}
+  {@render children?.()}
+</Button>

package/dist/blocks/button.svelte.d.ts

@@ -0,0 +1,32 @@
+import type { MouseEventHandler } from 'svelte/elements';
+export type ButtonProps = ButtonPrimitiveProps & {
+    loading?: boolean;
+    onClickPromise?: (e: Parameters<MouseEventHandler<HTMLButtonElement>>[0] | Parameters<MouseEventHandler<HTMLAnchorElement>>[0]) => Promise<void>;
+};
+export type Size = 'default' | 'xs' | 'sm' | 'lg';
+/**
+ * Map sizes to their icon/normal size variant
+ */
+export declare const sizeMap: {
+    readonly default: {
+        readonly icon: "icon";
+        readonly normal: "default";
+    };
+    readonly xs: {
+        readonly icon: "icon-xs";
+        readonly normal: "xs";
+    };
+    readonly sm: {
+        readonly icon: "icon-sm";
+        readonly normal: "sm";
+    };
+    readonly lg: {
+        readonly icon: "icon-lg";
+        readonly normal: "lg";
+    };
+};
+export { type ButtonSize, type ButtonVariant } from '../components/ui-extra/button';
+import { Button, type ButtonProps as ButtonPrimitiveProps } from '../components/ui-extra/button';
+declare const Button: import("svelte").Component<ButtonProps, {}, "ref">;
+type Button = ReturnType<typeof Button>;
+export default Button;

package/dist/blocks/casing.d.ts

@@ -0,0 +1,115 @@
+/** Converts a `camelCase` string to a `snake_case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('helloWorld'); // hello_world
+ * ```
+ */
+export declare function camelToSnake(str: string): string;
+/** Converts a `PascalCase` string to a `snake_case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('HelloWorld'); // hello_world
+ * ```
+ */
+export declare function pascalToSnake(str: string): string;
+/** Converts a `camelCase` string to a `kebab-case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('helloWorld'); // hello-world
+ * ```
+ */
+export declare function camelToKebab(str: string): string;
+/** Converts a `PascalCase` string to a `kebab-case` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToSnake('HelloWorld'); // hello-world
+ * ```
+ */
+export declare function pascalToKebab(str: string): string;
+/** Converts a `camelCase` string to a `PascalCase` string (makes first letter lowercase)
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToPascal('helloWorld'); // HelloWorld
+ * ```
+ */
+export declare function camelToPascal(str: string): string;
+/** Converts a `PascalCase` string to a `camelCase` string (makes first letter uppercase)
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * camelToPascal('HelloWorld'); // helloWorld
+ * ```
+ */
+export declare function pascalToCamel(str: string): string;
+/** Converts a `snake_case` string to a `PascalCase` string
+ *
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * snakeToPascal('hello_world'); // HelloWorld
+ * snakeToPascal('HELLO_WORLD'); // HelloWorld
+ * ```
+ */
+export declare function snakeToPascal(str: string): string;
+/** Converts a `snake_case` string to a `camelCase` string
+ *
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * snakeToCamel('hello_world'); // helloWorld
+ * snakeToCamel('HELLO_WORLD'); // helloWorld
+ * ```
+ */
+export declare function snakeToCamel(str: string): string;
+/** Converts a `kebab-case` string to a `PascalCase` string
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * kebabToPascal('hello-world'); // HelloWorld
+ * ```
+ */
+export declare function kebabToPascal(str: string): string;
+/** Converts a `kebab-case` string to a `camelCase` string
+ *
+ *
+ * @param str
+ * @returns
+ *
+ * ## Usage
+ * ```ts
+ * kebabToCamel('hello-world'); // helloWorld
+ * ```
+ */
+export declare function kebabToCamel(str: string): string;

package/dist/blocks/casing.js

@@ -0,0 +1,283 @@
+/*
+    Installed from @ieedan/std
+*/
+import { isLetter } from './is-letter.js';
+/** 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/blocks/ipv4-address.d.ts

@@ -0,0 +1,48 @@
+import { type Result } from './result.js';
+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/blocks/ipv4-address.js

@@ -0,0 +1,82 @@
+/*
+    Installed from @ieedan/std
+*/
+import { isNumber } from './is-number.js';
+import { Err, Ok } from './result.js';
+/** 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);
+}