@profidev/pleiades 1.7.0

package/.oxlintrc.base.json

@@ -0,0 +1,46 @@
+{
+  "plugins": ["typescript", "unicorn", "oxc"],
+  "categories": {
+    "correctness": "error",
+    "suspicious": "warn",
+    "perf": "warn",
+    "style": "warn",
+    "restriction": "warn"
+  },
+  "rules": {
+    "eslint/id-length": "off",
+    "eslint/max-statements": "off",
+    "eslint/no-continue": "off",
+    "eslint/no-ternary": "off",
+    "eslint/no-undefined": "off",
+    "eslint/no-magic-numbers": "off",
+    "oxc/no-async-await": "off",
+    "oxc/no-optional-chaining": "off",
+    "oxc/no-rest-spread-properties": "off",
+    "typescript/explicit-function-return-type": "off",
+    "typescript/no-non-null-assertion": "off",
+    "typescript/no-explicit-any": "off",
+    "typescript/explicit-module-boundary-types": "off",
+    "typescript/parameter-properties": "off",
+    "eslint-plugin-unicorn/prefer-global-this": "off",
+    "eslint-plugin-unicorn/prefer-ternary": "off",
+    "eslint-plugin-unicorn/no-await-expression-member": "off",
+    "eslint/no-use-before-define": "off",
+    "eslint/no-empty-function": "off",
+    "typescript/no-extraneous-class": "off",
+    "eslint/max-params": "off",
+    "sort-imports": [
+      "warn",
+      {
+        "ignoreDeclarationSort": true
+      }
+    ]
+  },
+  "env": {
+    "builtin": true
+  },
+  "options": {
+    "typeAware": true,
+    "typeCheck": true
+  }
+}

package/README.md

@@ -0,0 +1,3 @@
+# Pleiades UI Components
+
+Credits for Base Components https://www.shadcn-svelte.com/

package/dist/actions/active.svelte.d.ts

@@ -0,0 +1,43 @@
+export type Options = {
+    /** Determines if the route should be active for subdirectories.
+     *
+     * @default true
+     */
+    activeForSubdirectories?: boolean;
+    /** Determines if the href of the `<a/>` tag is a `#` route
+     *
+     *  @default false
+     */
+    isHash?: boolean;
+    /** Determines if the href of the `<a/>` tag is a search route
+     *
+     *  @default false
+     */
+    isSearch?: boolean;
+    url: URL;
+};
+/** 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 declare function active(node: HTMLAnchorElement, opts?: Omit<Options, 'url'>): void;
+/** 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 declare function attachActive(opts?: Omit<Options, 'url'>): {
+    [x: symbol]: (node: HTMLAnchorElement) => void;
+};
+export declare const checkIsActive: (nodeHref: string, { activeForSubdirectories, url, isHash, isSearch }: Options) => boolean;

package/dist/actions/active.svelte.js

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

@@ -0,0 +1,52 @@
+export type Options = {
+    /** Event to use to detect the shortcut @default 'keydown' */
+    event?: 'keydown' | 'keyup' | 'keypress';
+    /** Function to be called when the shortcut is pressed */
+    callback: (e: KeyboardEvent) => void;
+    /** Should the `Shift` key be pressed */
+    shift?: boolean;
+    /** Should the `Ctrl` / `Command` key be pressed */
+    ctrl?: boolean;
+    /** Should the `Alt` key be pressed */
+    alt?: boolean;
+    /** Which key should be pressed */
+    key: Key;
+    /** Control whether or not the shortcut prevents default behavior @default true */
+    preventDefault?: boolean;
+    /** Control whether or not the shortcut stops propagation @default false */
+    stopPropagation?: boolean;
+};
+/** Allows you to configure one or more shortcuts based on the key events of an element.
+ *
+ * ## Usage
+ * ```svelte
+ * <!-- Ctrl + K Shortcut -->
+ * <svelte:window use:shortcut={
+ * 			{
+ * 				ctrl: true,
+ * 				key: 'k',
+ * 				callback: commandMenu.toggle
+ * 			}
+ * 		}
+ * />
+ * ```
+ */
+export declare const shortcut: (node: HTMLElement, options: Options[] | Options) => void;
+/** Allows you to configure one or more shortcuts based on the key events of an element.
+ *
+ * ## Usage
+ * ```svelte
+ * <!-- Ctrl + K Shortcut -->
+ * <svelte:window
+ * 	  {...attachShortcut({
+ * 		  ctrl: true,
+ * 		  key: 'k',
+ * 		  callback: commandMenu.toggle
+ * 	  })}
+ * />
+ * ```
+ */
+export declare function attachShortcut(opts: Options[] | Options): {
+    [x: symbol]: (node: HTMLElement) => void;
+};
+export type Key = 'backspace' | 'tab' | 'enter' | 'shift(left)' | 'shift(right)' | 'ctrl(left)' | 'ctrl(right)' | 'alt(left)' | 'alt(right)' | 'pause/break' | 'caps lock' | 'escape' | 'space' | 'page up' | 'page down' | 'end' | 'home' | 'left arrow' | 'up arrow' | 'right arrow' | 'down arrow' | 'print screen' | 'insert' | 'delete' | '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z' | 'left window key' | 'right window key' | 'select key (Context Menu)' | 'numpad 0' | 'numpad 1' | 'numpad 2' | 'numpad 3' | 'numpad 4' | 'numpad 5' | 'numpad 6' | 'numpad 7' | 'numpad 8' | 'numpad 9' | 'multiply' | 'add' | 'subtract' | 'decimal point' | 'divide' | 'f1' | 'f2' | 'f3' | 'f4' | 'f5' | 'f6' | 'f7' | 'f8' | 'f9' | 'f10' | 'f11' | 'f12' | 'num lock' | 'scroll lock' | 'audio volume mute' | 'audio volume down' | 'audio volume up' | 'media player' | 'launch application 1' | 'launch application 2' | 'semi-colon' | 'equal sign' | 'comma' | 'dash' | 'period' | 'forward slash' | 'Backquote/Grave accent' | 'open bracket' | 'back slash' | 'close bracket' | 'single quote';

package/dist/actions/shortcut.svelte.js

@@ -0,0 +1,74 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+import { createAttachmentKey } from 'svelte/attachments';
+/** Allows you to configure one or more shortcuts based on the key events of an element.
+ *
+ * ## Usage
+ * ```svelte
+ * <!-- Ctrl + K Shortcut -->
+ * <svelte:window use:shortcut={
+ * 			{
+ * 				ctrl: true,
+ * 				key: 'k',
+ * 				callback: commandMenu.toggle
+ * 			}
+ * 		}
+ * />
+ * ```
+ */
+export const shortcut = (node, options) => {
+    const handleKeydown = (e, options) => {
+        if (options.ctrl && !e.ctrlKey && !e.metaKey)
+            return;
+        if (options.alt && !e.altKey)
+            return;
+        if (options.shift && !e.shiftKey)
+            return;
+        if (e.key.toLocaleLowerCase() !== options.key.toLocaleLowerCase())
+            return;
+        if (options.preventDefault === undefined || options.preventDefault) {
+            e.preventDefault();
+        }
+        if (options.stopPropagation) {
+            e.stopPropagation();
+        }
+        options.callback(e);
+    };
+    $effect(() => {
+        let optionsArr = [];
+        if (Array.isArray(options)) {
+            optionsArr = options;
+        }
+        else {
+            optionsArr = [options];
+        }
+        for (const opt of optionsArr) {
+            node.addEventListener(opt.event ?? 'keydown', (e) => handleKeydown(e, opt));
+        }
+        return () => {
+            for (const opt of optionsArr) {
+                node.removeEventListener(opt.event ?? 'keydown', (e) => handleKeydown(e, opt));
+            }
+        };
+    });
+};
+/** Allows you to configure one or more shortcuts based on the key events of an element.
+ *
+ * ## Usage
+ * ```svelte
+ * <!-- Ctrl + K Shortcut -->
+ * <svelte:window
+ * 	  {...attachShortcut({
+ * 		  ctrl: true,
+ * 		  key: 'k',
+ * 		  callback: commandMenu.toggle
+ * 	  })}
+ * />
+ * ```
+ */
+export function attachShortcut(opts) {
+    return {
+        [createAttachmentKey()]: (node) => shortcut(node, opts)
+    };
+}

package/dist/actions/typewriter.svelte.d.ts

@@ -0,0 +1,17 @@
+export type Options = {
+    speed: number;
+    delay: number;
+    onComplete?: () => void;
+};
+export declare const typewriter: (node: HTMLElement, { speed, delay, onComplete }: Partial<Options>) => {
+    delay: number;
+    duration: number;
+    tick: (t: number) => void;
+};
+export declare function attachTypewriter(opts?: Partial<Options>): {
+    [x: symbol]: (node: HTMLElement) => {
+        delay: number;
+        duration: number;
+        tick: (t: number) => void;
+    };
+};

package/dist/actions/typewriter.svelte.js

@@ -0,0 +1,23 @@
+/*
+    Installed from @ieedan/shadcn-svelte-extras
+*/
+import { createAttachmentKey } from 'svelte/attachments';
+export const typewriter = (node, { speed = 1, delay = 0, onComplete }) => {
+    const text = node.textContent ?? '';
+    const duration = text.length / (speed * 0.01);
+    return {
+        delay,
+        duration,
+        tick: (t) => {
+            const i = Math.trunc(text.length * t);
+            node.textContent = text.slice(0, i);
+            if (node.textContent.length === text.length)
+                onComplete?.();
+        }
+    };
+};
+export function attachTypewriter(opts = {}) {
+    return {
+        [createAttachmentKey()]: (node) => typewriter(node, opts)
+    };
+}

package/dist/backend/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.svelte.js';
+export * from './util.svelte.js';
+export * from './updater.svelte.js';

package/dist/backend/index.js

@@ -0,0 +1,3 @@
+export * from './types.svelte.js';
+export * from './util.svelte.js';
+export * from './updater.svelte.js';

package/dist/backend/types.svelte.d.ts

@@ -0,0 +1,26 @@
+export declare enum RequestError {
+    BadRequest = "BadRequest",
+    Unauthorized = "Unauthorized",
+    Forbidden = "Forbidden",
+    NotFound = "NotFound",
+    NotAcceptable = "NotAcceptable",
+    RequestTimeout = "RequestTimeout",
+    Conflict = "Conflict",
+    Gone = "Gone",
+    ContentTooLarge = "ContentTooLarge",
+    UnsupportedMediaType = "UnsupportedMediaType",
+    UnprocessableEntity = "UnprocessableEntity",
+    TooManyRequests = "TooManyRequests",
+    InternalServerError = "InternalServerError",
+    NotImplemented = "NotImplemented",
+    BadGateway = "BadGateway",
+    ServiceUnavailable = "ServiceUnavailable",
+    GatewayTimeout = "GatewayTimeout",
+    InsufficientStorage = "InsufficientStorage",
+    Other = "Other"
+}
+export declare enum ResponseType {
+    Json = "Json",
+    Text = "Text",
+    None = "None"
+}

package/dist/backend/types.svelte.js

@@ -0,0 +1,28 @@
+export var RequestError;
+(function (RequestError) {
+    RequestError["BadRequest"] = "BadRequest";
+    RequestError["Unauthorized"] = "Unauthorized";
+    RequestError["Forbidden"] = "Forbidden";
+    RequestError["NotFound"] = "NotFound";
+    RequestError["NotAcceptable"] = "NotAcceptable";
+    RequestError["RequestTimeout"] = "RequestTimeout";
+    RequestError["Conflict"] = "Conflict";
+    RequestError["Gone"] = "Gone";
+    RequestError["ContentTooLarge"] = "ContentTooLarge";
+    RequestError["UnsupportedMediaType"] = "UnsupportedMediaType";
+    RequestError["UnprocessableEntity"] = "UnprocessableEntity";
+    RequestError["TooManyRequests"] = "TooManyRequests";
+    RequestError["InternalServerError"] = "InternalServerError";
+    RequestError["NotImplemented"] = "NotImplemented";
+    RequestError["BadGateway"] = "BadGateway";
+    RequestError["ServiceUnavailable"] = "ServiceUnavailable";
+    RequestError["GatewayTimeout"] = "GatewayTimeout";
+    RequestError["InsufficientStorage"] = "InsufficientStorage";
+    RequestError["Other"] = "Other";
+})(RequestError || (RequestError = {}));
+export var ResponseType;
+(function (ResponseType) {
+    ResponseType["Json"] = "Json";
+    ResponseType["Text"] = "Text";
+    ResponseType["None"] = "None";
+})(ResponseType || (ResponseType = {}));

package/dist/backend/updater.svelte.d.ts

@@ -0,0 +1,2 @@
+export declare const connectWebsocket: <T>(user: string, handleMessage: (msg: T, user: string) => void) => void;
+export declare const disconnectWebsocket: () => void;

package/dist/backend/updater.svelte.js

@@ -0,0 +1,47 @@
+import { browser } from '$app/environment';
+import { sleep } from '../util/interval.svelte';
+let updater = $state(browser && undefined);
+let interval = 0;
+let disconnect = false;
+// oxlint-disable-next-line no-unnecessary-type-parameters
+export const connectWebsocket = (user, handleMessage) => {
+    if (updater === false || updater) {
+        return;
+    }
+    createWebsocket(user, handleMessage);
+};
+// oxlint-disable-next-line no-unnecessary-type-parameters
+const createWebsocket = (user, handleMessage) => {
+    updater = new WebSocket('/api/ws/updater');
+    // oxlint-disable-next-line prefer-add-event-listener
+    updater.onmessage = (event) => {
+        const msg = JSON.parse(event.data);
+        handleMessage(msg, user);
+    };
+    // oxlint-disable-next-line prefer-add-event-listener
+    updater.onclose = async () => {
+        clearInterval(interval);
+        if (disconnect) {
+            return;
+        }
+        await sleep(1000);
+        createWebsocket(user, handleMessage);
+    };
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    interval = setInterval(() => {
+        if (!updater ||
+            updater.readyState === updater.CLOSING ||
+            updater.readyState === updater.CLOSED) {
+            clearInterval(interval);
+            return;
+        }
+        updater.send('heartbeat');
+    }, 10_000);
+};
+export const disconnectWebsocket = () => {
+    if (updater) {
+        disconnect = true;
+        updater.close();
+        updater = undefined;
+    }
+};

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

@@ -0,0 +1,14 @@
+import { RequestError, ResponseType } from './types.svelte';
+export interface RequestOptions {
+    res_type?: ResponseType;
+    body?: any;
+    content_type?: string;
+    signal?: AbortSignal;
+    fetch?: typeof fetch;
+}
+export declare const patch: <T = undefined>(path: string, options?: RequestOptions) => Promise<T | RequestError>;
+export declare const put: <T = undefined>(path: string, options?: RequestOptions) => Promise<T | RequestError>;
+export declare const delete_: <T = undefined>(path: string, options?: RequestOptions) => Promise<T | RequestError>;
+export declare const post: <T = undefined>(path: string, options?: RequestOptions) => Promise<T | RequestError>;
+export declare const get: <T = undefined>(path: string, options?: Omit<RequestOptions, "body">) => Promise<T | RequestError>;
+export declare const request: <T = undefined>(path: string, method: string, { res_type, body, content_type, signal, fetch }?: RequestOptions) => Promise<T | RequestError>;

package/dist/backend/util.svelte.js

@@ -0,0 +1,123 @@
+import { RequestError, ResponseType } from './types.svelte';
+export const patch = async (path, options = {}) => await request(path, 'PATCH', options);
+export const put = async (path, options = {}) => await request(path, 'PUT', options);
+export const delete_ = async (path, options = {}) => await request(path, 'DELETE', options);
+export const post = async (path, options = {}) => await request(path, 'POST', options);
+export const get = async (path, options = {}) => await request(path, 'GET', options);
+// oxlint-disable-next-line complexity
+export const request = async (path, method, { res_type, body, content_type, signal, fetch } = {}) => {
+    const res_type_ = res_type ?? ResponseType.None;
+    let content_type_ = content_type;
+    let body_ = body;
+    if (body_ instanceof ArrayBuffer) {
+        content_type_ = 'application/octet-stream';
+    }
+    else if (body_ instanceof Blob) {
+        content_type_ = body_.type;
+        body_ = body_.stream();
+    }
+    else if (typeof body_ === 'string') {
+        content_type_ = 'text/plain';
+    }
+    else if (typeof body_ === 'object' && body_ !== null) {
+        content_type_ = 'application/json';
+        body_ = JSON.stringify(body_);
+    }
+    const headers = {};
+    if (content_type_) {
+        headers['Content-Type'] = content_type_;
+    }
+    const fetch_ = fetch ?? globalThis.fetch;
+    try {
+        const res = await fetch_(path, {
+            body: body_,
+            headers,
+            method,
+            signal
+        });
+        switch (res.status) {
+            case 200: {
+                break;
+            }
+            case 400: {
+                return RequestError.BadRequest;
+            }
+            case 401: {
+                return RequestError.Unauthorized;
+            }
+            case 403: {
+                return RequestError.Forbidden;
+            }
+            case 404: {
+                return RequestError.NotFound;
+            }
+            case 406: {
+                return RequestError.NotAcceptable;
+            }
+            case 408: {
+                return RequestError.RequestTimeout;
+            }
+            case 409: {
+                return RequestError.Conflict;
+            }
+            case 410: {
+                return RequestError.Gone;
+            }
+            case 413: {
+                return RequestError.ContentTooLarge;
+            }
+            case 415: {
+                return RequestError.UnsupportedMediaType;
+            }
+            case 422: {
+                return RequestError.UnprocessableEntity;
+            }
+            case 429: {
+                return RequestError.TooManyRequests;
+            }
+            case 500: {
+                return RequestError.InternalServerError;
+            }
+            case 501: {
+                return RequestError.NotImplemented;
+            }
+            case 502: {
+                return RequestError.BadGateway;
+            }
+            case 503: {
+                return RequestError.ServiceUnavailable;
+            }
+            case 504: {
+                return RequestError.GatewayTimeout;
+            }
+            case 507: {
+                return RequestError.InsufficientStorage;
+            }
+            default: {
+                return RequestError.Other;
+            }
+        }
+        switch (res_type_) {
+            case ResponseType.Json: {
+                const json = await res.json();
+                // oxlint-disable-next-line no-unsafe-type-assertion
+                return json;
+            }
+            case ResponseType.Text: {
+                const text = await res.text();
+                // oxlint-disable-next-line no-unsafe-type-assertion
+                return text;
+            }
+            case ResponseType.None: {
+                // oxlint-disable-next-line no-unsafe-type-assertion
+                return undefined;
+            }
+            default: {
+                return RequestError.Other;
+            }
+        }
+    }
+    catch {
+        return RequestError.Other;
+    }
+};

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

@@ -0,0 +1,43 @@
+export type Options = {
+    /** Determines if the route should be active for subdirectories.
+     *
+     * @default true
+     */
+    activeForSubdirectories?: boolean;
+    /** Determines if the href of the `<a/>` tag is a `#` route
+     *
+     *  @default false
+     */
+    isHash?: boolean;
+    /** Determines if the href of the `<a/>` tag is a search route
+     *
+     *  @default false
+     */
+    isSearch?: boolean;
+    url: URL;
+};
+/** 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 declare function active(node: HTMLAnchorElement, opts?: Omit<Options, 'url'>): void;
+/** 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 declare function attachActive(opts?: Omit<Options, 'url'>): {
+    [x: symbol]: (node: HTMLAnchorElement) => void;
+};
+export declare const checkIsActive: (nodeHref: string, { activeForSubdirectories, url, isHash, isSearch }: Options) => boolean;