@profidev/pleiades 1.7.0

package/dist/hooks/use-boolean.svelte.js

@@ -0,0 +1,49 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+/** A hook for easy use of boolean values
+ *
+ * ## Usage
+ * ```svelte
+ * <script lang="ts">
+ *      const open = new UseBoolean();
+ * </script>
+ *
+ * <p>Value is: {open.current}</p>
+ * <button onclick={open.toggle}>Toggle</button>
+ * <button onclick={open.setTrue}>Set True</button>
+ * <button onclick={open.setFalse}>Set False</button>
+ * <button onclick={() => {
+ *      open.current = true;
+ * }}>
+ *      Custom
+ * </button>
+ * ```
+ */
+export class UseBoolean {
+    #current = $state(false);
+    constructor(defaultValue = false) {
+        this.#current = defaultValue;
+        this.toggle = this.toggle.bind(this);
+        this.setTrue = this.setTrue.bind(this);
+        this.setFalse = this.setFalse.bind(this);
+    }
+    /** Toggles the current state */
+    toggle() {
+        this.#current = !this.#current;
+    }
+    /** Sets the current state to true */
+    setTrue() {
+        this.#current = true;
+    }
+    /** Sets the current state to false */
+    setFalse() {
+        this.#current = false;
+    }
+    get current() {
+        return this.#current;
+    }
+    set current(val) {
+        this.#current = val;
+    }
+}

package/dist/hooks/use-clipboard.svelte.d.ts

@@ -0,0 +1,49 @@
+type Options = {
+    /** The time before the copied status is reset. */
+    delay: number;
+};
+/** Use this hook to copy text to the clipboard and show a copied state.
+ *
+ * ## Usage
+ * ```svelte
+ * <script lang="ts">
+ * 		import { UseClipboard } from "./use-clipboard.svelte";
+ *
+ * 		const clipboard = new UseClipboard();
+ * </script>
+ *
+ * <button onclick={clipboard.copy('Hello, World!')}>
+ *     {#if clipboard.copied === 'success'}
+ *         Copied!
+ *     {:else if clipboard.copied === 'failure'}
+ *         Failed to copy!
+ *     {:else}
+ *         Copy
+ *     {/if}
+ * </button>
+ * ```
+ *
+ */
+export declare class UseClipboard {
+    #private;
+    private delay;
+    private timeout;
+    constructor({ delay }?: Partial<Options>);
+    /** Copies the given text to the users clipboard.
+     *
+     * ## Usage
+     * ```ts
+     * clipboard.copy('Hello, World!');
+     * ```
+     *
+     * @param text
+     * @returns
+     */
+    copy(text: string): Promise<"success" | "failure">;
+    /** true when the user has just copied to the clipboard. */
+    get copied(): boolean;
+    /**	Indicates whether a copy has occurred
+     * and gives a status of either `success` or `failure`. */
+    get status(): "success" | "failure" | undefined;
+}
+export {};

package/dist/hooks/use-clipboard.svelte.js

@@ -0,0 +1,73 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+/** Use this hook to copy text to the clipboard and show a copied state.
+ *
+ * ## Usage
+ * ```svelte
+ * <script lang="ts">
+ * 		import { UseClipboard } from "./use-clipboard.svelte";
+ *
+ * 		const clipboard = new UseClipboard();
+ * </script>
+ *
+ * <button onclick={clipboard.copy('Hello, World!')}>
+ *     {#if clipboard.copied === 'success'}
+ *         Copied!
+ *     {:else if clipboard.copied === 'failure'}
+ *         Failed to copy!
+ *     {:else}
+ *         Copy
+ *     {/if}
+ * </button>
+ * ```
+ *
+ */
+export class UseClipboard {
+    #copiedStatus = $state();
+    delay;
+    timeout = undefined;
+    constructor({ delay = 500 } = {}) {
+        this.delay = delay;
+    }
+    /** Copies the given text to the users clipboard.
+     *
+     * ## Usage
+     * ```ts
+     * clipboard.copy('Hello, World!');
+     * ```
+     *
+     * @param text
+     * @returns
+     */
+    async copy(text) {
+        if (this.timeout) {
+            this.#copiedStatus = undefined;
+            clearTimeout(this.timeout);
+        }
+        try {
+            await navigator.clipboard.writeText(text);
+            this.#copiedStatus = 'success';
+            this.timeout = setTimeout(() => {
+                this.#copiedStatus = undefined;
+            }, this.delay);
+        }
+        catch {
+            // an error can occur when not in the browser or if the user hasn't given clipboard access
+            this.#copiedStatus = 'failure';
+            this.timeout = setTimeout(() => {
+                this.#copiedStatus = undefined;
+            }, this.delay);
+        }
+        return this.#copiedStatus;
+    }
+    /** true when the user has just copied to the clipboard. */
+    get copied() {
+        return this.#copiedStatus === 'success';
+    }
+    /**	Indicates whether a copy has occurred
+     * and gives a status of either `success` or `failure`. */
+    get status() {
+        return this.#copiedStatus;
+    }
+}

package/dist/hooks/use-frecency.svelte.d.ts

@@ -0,0 +1,19 @@
+import { PersistedState } from 'runed';
+type FrecencyItem = {
+    uses: number;
+    lastUsage: number;
+};
+type PersistedStateOptions<T> = ConstructorParameters<typeof PersistedState<T>>[2];
+type UseFrecencyOptions = PersistedStateOptions<FrecencyMap> & {
+    maxItems?: number;
+};
+type FrecencyMap = Record<string, FrecencyItem | undefined>;
+export declare class UseFrecency {
+    #private;
+    readonly opts: UseFrecencyOptions;
+    constructor(key: string, initialValue?: FrecencyMap, opts?: UseFrecencyOptions);
+    use(key: string): void;
+    get items(): string[];
+    clear(): void;
+}
+export {};

package/dist/hooks/use-frecency.svelte.js

@@ -0,0 +1,36 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+import { PersistedState } from 'runed';
+export class UseFrecency {
+    opts;
+    #items;
+    constructor(key, initialValue = {}, opts = {}) {
+        this.opts = opts;
+        this.#items = new PersistedState(key, initialValue, this.opts);
+        this.use = this.use.bind(this);
+    }
+    use(key) {
+        const item = this.#items.current[key];
+        this.#items.current[key] = {
+            uses: 1 + (item?.uses ?? 0),
+            lastUsage: Date.now()
+        };
+    }
+    get items() {
+        return Array.from(Object.entries(this.#items.current))
+            .filter(([_a, a]) => a !== undefined)
+            .sort(([_a, a], [_b, b]) => {
+            if (a.uses > b.uses)
+                return -1;
+            if (b.uses > a.uses)
+                return 1;
+            return a.lastUsage - b.lastUsage;
+        })
+            .slice(0, this.opts.maxItems)
+            .map(([key]) => key);
+    }
+    clear() {
+        this.#items.current = {};
+    }
+}

package/dist/hooks/use-media.svelte.d.ts

@@ -0,0 +1,10 @@
+export type Breakpoints<K extends string> = Record<K, string>;
+/** Based on the default Tailwind CSS breakpoints https://tailwindcss.com/docs/responsive-design.
+ * A breakpoint is `true` when the width of the screen is greater than or equal to the breakpoint. */
+export declare const TAILWIND_BREAKPOINTS: Breakpoints<'sm' | 'md' | 'lg' | 'xl' | '2xl'>;
+/** Dynamically creates media queries for the provided breakpoints allowing you to access them as `media.<name>`.
+ *
+ * @param breakpoints
+ * @returns
+ */
+export declare function useMedia<K extends string = keyof typeof TAILWIND_BREAKPOINTS>(breakpoints?: Breakpoints<K>): Record<K, boolean>;

package/dist/hooks/use-media.svelte.js

@@ -0,0 +1,28 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+import { MediaQuery } from 'svelte/reactivity';
+/** Based on the default Tailwind CSS breakpoints https://tailwindcss.com/docs/responsive-design.
+ * A breakpoint is `true` when the width of the screen is greater than or equal to the breakpoint. */
+export const TAILWIND_BREAKPOINTS = {
+    sm: '40rem',
+    md: '48rem',
+    lg: '64rem',
+    xl: '80rem',
+    '2xl': '96rem'
+};
+/** Dynamically creates media queries for the provided breakpoints allowing you to access them as `media.<name>`.
+ *
+ * @param breakpoints
+ * @returns
+ */
+export function useMedia(breakpoints = TAILWIND_BREAKPOINTS) {
+    const queries = {};
+    for (const [name, size] of Object.entries(breakpoints)) {
+        const query = new MediaQuery(`min-width: ${size}`);
+        Object.defineProperty(queries, name, {
+            get: () => query.current
+        });
+    }
+    return queries;
+}

package/dist/hooks/use-promise.svelte.d.ts

@@ -0,0 +1,25 @@
+/** A hook for working with promises reactively when the `{#await}` block is not an option.
+ *
+ * ## Usage
+ * ```svelte
+ * <script lang="ts">
+ *      let { data } = $props();
+ *
+ *      const version = new UsePromise(data.version, '1.0.0');
+ * </script>
+ *
+ * <!-- 1.0.0 until resolved -->
+ * <Command args={[`jsrepo@${version.current}`, 'add', 'hooks/use-promise.svelte']} />
+ * ```
+ */
+export declare class UsePromise<T> {
+    #private;
+    readonly fallback?: T | undefined;
+    constructor(promise: Promise<T>, fallback?: T | undefined);
+    /** Returns the value of the resolved promise or the fallback value (if provided)*/
+    get current(): T | undefined;
+    /** Returns true when the promise has been resolved */
+    get isResolved(): boolean;
+    /** Returns the original promise */
+    get promise(): Promise<T> | undefined;
+}

package/dist/hooks/use-promise.svelte.js

@@ -0,0 +1,43 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+/** A hook for working with promises reactively when the `{#await}` block is not an option.
+ *
+ * ## Usage
+ * ```svelte
+ * <script lang="ts">
+ *      let { data } = $props();
+ *
+ *      const version = new UsePromise(data.version, '1.0.0');
+ * </script>
+ *
+ * <!-- 1.0.0 until resolved -->
+ * <Command args={[`jsrepo@${version.current}`, 'add', 'hooks/use-promise.svelte']} />
+ * ```
+ */
+export class UsePromise {
+    fallback;
+    #isResolved = $state(false);
+    #resolvedValue = $state();
+    #promise = $state();
+    constructor(promise, fallback) {
+        this.fallback = fallback;
+        this.#promise = promise;
+        this.#promise.then((v) => {
+            this.#resolvedValue = v;
+            this.#isResolved = true;
+        });
+    }
+    /** Returns the value of the resolved promise or the fallback value (if provided)*/
+    get current() {
+        return this.#isResolved ? this.#resolvedValue : this.fallback;
+    }
+    /** Returns true when the promise has been resolved */
+    get isResolved() {
+        return this.#isResolved;
+    }
+    /** Returns the original promise */
+    get promise() {
+        return this.#promise;
+    }
+}

package/dist/hooks/use-toc.svelte.d.ts

@@ -0,0 +1,33 @@
+export type HeadingKind = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export type Heading = {
+    index: number;
+    ref: Element;
+    kind: HeadingKind;
+    id?: string;
+    level: number;
+    label: string;
+    active: boolean;
+    children: Heading[];
+};
+export declare const INDEX_ATTRIBUTE = "data-toc-index";
+/** A hook for generating a table of contents using the page content.
+ *
+ * ## Usage
+ * ```svelte
+ * <script lang="ts">
+ * 		const toc = new UseToc();
+ * </script>
+ *
+ * <div bind:this={toc.ref} style="display: contents;">
+ * 		<h1>Table of Contents</h1>
+ * 		<h2>Usage</h2>
+ * </div>
+ * ```
+ */
+export declare class UseToc {
+    #private;
+    set ref(ref: HTMLElement | undefined);
+    get ref(): HTMLElement | undefined;
+    /** The generated table of contents */
+    get current(): Heading[];
+}

package/dist/hooks/use-toc.svelte.js

@@ -0,0 +1,130 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+import { SvelteMap } from 'svelte/reactivity';
+export const INDEX_ATTRIBUTE = 'data-toc-index';
+/** A hook for generating a table of contents using the page content.
+ *
+ * ## Usage
+ * ```svelte
+ * <script lang="ts">
+ * 		const toc = new UseToc();
+ * </script>
+ *
+ * <div bind:this={toc.ref} style="display: contents;">
+ * 		<h1>Table of Contents</h1>
+ * 		<h2>Usage</h2>
+ * </div>
+ * ```
+ */
+export class UseToc {
+    #ref = $state();
+    #toc = $state([]);
+    // This sets everything up once #ref is bound
+    set ref(ref) {
+        this.#ref = ref;
+        if (!this.#ref)
+            return;
+        this.#toc = getToc(this.#ref);
+        // should detect if a heading is added / removed / updated
+        const mutationObserver = new MutationObserver(() => {
+            if (!this.#ref)
+                return;
+            this.#toc = getToc(this.#ref);
+        });
+        mutationObserver.observe(this.#ref, { childList: true, subtree: true });
+        const resetActiveHeading = (headings) => {
+            for (let i = 0; i < headings.length; i++) {
+                headings[i].active = false;
+                resetActiveHeading(headings[i].children);
+            }
+        };
+        const setHeadingActive = (headings, index) => {
+            for (let i = 0; i < headings.length; i++) {
+                if (index === headings[i].index) {
+                    headings[i].active = true;
+                    break;
+                }
+                setHeadingActive(headings[i].children, index);
+            }
+        };
+        // reactive to the table of contents
+        $effect(() => {
+            const sectionVisibility = new SvelteMap();
+            const observer = new IntersectionObserver((entries) => {
+                entries.forEach((entry) => sectionVisibility.set(entry.target, entry.intersectionRatio));
+                // headings that are (partly) visible
+                const visible = [...sectionVisibility.entries()]
+                    .filter(([, ratio]) => ratio > 0)
+                    // sort by distance from viewport top
+                    .sort(([a], [b]) => a.getBoundingClientRect().top - b.getBoundingClientRect().top);
+                if (visible.length === 0)
+                    return;
+                // the heading nearest to the top wins
+                const activeEl = visible[0][0];
+                const idx = +activeEl.getAttribute(INDEX_ATTRIBUTE);
+                resetActiveHeading(this.#toc);
+                setHeadingActive(this.#toc, idx);
+            });
+            const observe = (heading) => {
+                observer.observe(heading.ref);
+                heading.children.forEach(observe);
+            };
+            this.#toc.forEach(observe);
+            return () => observer.disconnect();
+        });
+    }
+    get ref() {
+        return this.#ref;
+    }
+    /** The generated table of contents */
+    get current() {
+        return this.#toc;
+    }
+}
+const createHeading = (element, index) => {
+    const kind = element.tagName.toLowerCase();
+    element.setAttribute(INDEX_ATTRIBUTE, index.toString());
+    return {
+        index,
+        ref: element,
+        kind,
+        id: element.id,
+        level: parseInt(kind[1]),
+        label: element.innerText ?? '',
+        active: false,
+        children: []
+    };
+};
+/** Gets all of the headings contained in the provided element and create a table of contents.
+ *
+ * @param el
+ * @returns
+ */
+const getToc = (el) => {
+    const headings = Array.from(el.querySelectorAll('h1, h2, h3, h4, h5, h6')).map((h, i) => createHeading(h, i));
+    if (headings.length === 0)
+        return [];
+    const toc = [];
+    let i = 0;
+    while (i < headings.length) {
+        const heading = headings[i];
+        const nextIndex = addChildren(headings, heading, i + 1);
+        toc.push(heading);
+        i = nextIndex;
+    }
+    return toc;
+};
+const addChildren = (headings, base, index) => {
+    let i = index;
+    while (i < headings.length) {
+        const sub = headings[i];
+        // example: h1 < h2 or h1 = h1
+        if (sub.level <= base.level)
+            break;
+        const nextIndex = addChildren(headings, sub, i + 1);
+        base.children.push(sub);
+        i = nextIndex;
+    }
+    return i;
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const dummy = 0;

package/dist/index.js

@@ -0,0 +1 @@
+export const dummy = 0;

package/dist/util/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;