fuma 0.0.1

package/dist/action/selector.js

@@ -0,0 +1,71 @@
+export function selector(node, { trigger, focusIndex = -1, listQuerySelector = 'ul', itemsQuerySelector = 'li', onSelect = () => { }, onFocus = () => { }, keyDownEvent = undefined, keyDownPreventDefault = true, }) {
+    trigger?.addEventListener('keydown', handleKeydown);
+    function handleKeydown(event) {
+        const items = node.querySelectorAll(itemsQuerySelector);
+        if (event.key === 'Enter') {
+            if (keyDownPreventDefault)
+                event.preventDefault();
+            onSelect(focusIndex);
+            return;
+        }
+        if (event.key === 'ArrowUp') {
+            if (keyDownPreventDefault)
+                event.preventDefault();
+            focusIndex--;
+            if (focusIndex < 0)
+                focusIndex = items.length - 1;
+            onFocus(focusIndex);
+            scrollToSelected(items);
+            return;
+        }
+        if (event.key === 'ArrowDown') {
+            if (keyDownPreventDefault)
+                event.preventDefault();
+            focusIndex++;
+            if (focusIndex > items.length - 1)
+                focusIndex = 0;
+            onFocus(focusIndex);
+            scrollToSelected(items);
+            return;
+        }
+    }
+    function scrollToSelected(items) {
+        const list = node.tagName === 'UL' ? node : node.querySelector(listQuerySelector);
+        if (!(list instanceof HTMLElement)) {
+            console.error('wrapper element not found');
+            return;
+        }
+        const item = items[focusIndex];
+        if (!item)
+            return;
+        const top = item.offsetTop - 4;
+        if (top < list.scrollTop) {
+            list.scrollTo({ top });
+            return;
+        }
+        const bottom = item.offsetTop + item.offsetHeight;
+        const delta = bottom - (list.scrollTop + list.offsetHeight) + 10;
+        if (delta > 0) {
+            list.scrollTo({ top: list.scrollTop + delta });
+            return;
+        }
+    }
+    return {
+        update(props) {
+            if (props.focusIndex !== undefined)
+                focusIndex = props.focusIndex;
+            if (props.trigger) {
+                trigger?.removeEventListener('keydown', handleKeydown);
+                trigger = props.trigger;
+                trigger?.addEventListener('keydown', handleKeydown);
+            }
+            if (props.keyDownEvent && keyDownEvent !== props.keyDownEvent) {
+                keyDownEvent = props.keyDownEvent;
+                handleKeydown(keyDownEvent);
+            }
+        },
+        destroy() {
+            trigger?.removeEventListener('keydown', handleKeydown);
+        },
+    };
+}

package/dist/action/tip.d.ts

@@ -0,0 +1,6 @@
+import { type TippyProps } from '../utils/tippy.js';
+export declare function tip(node: HTMLElement, options?: Partial<TippyProps> & {
+    disable?: boolean;
+}): {
+    destroy(): void;
+} | undefined;

package/dist/action/tip.js

@@ -0,0 +1,12 @@
+import { tippy } from '../utils/tippy.js';
+export function tip(node, options = { disable: false }) {
+    const { disable, ...tippyProps } = options;
+    if (disable)
+        return;
+    const _tip = tippy(node, tippyProps);
+    return {
+        destroy() {
+            _tip.destroy();
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ui/index.js';
+export * from './utils/index.js';
+export * from './store/index.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './ui/index.js';
+export * from './utils/index.js';
+export * from './store/index.js';

package/dist/server/index.d.ts

@@ -0,0 +1,5 @@
+export * from './json.js';
+export * from './parseFormData.js';
+export * from './parseQuery.js';
+export * from './sse.js';
+export * from './try.js';

package/dist/server/index.js

@@ -0,0 +1,5 @@
+export * from './json.js';
+export * from './parseFormData.js';
+export * from './parseQuery.js';
+export * from './sse.js';
+export * from './try.js';

package/dist/server/json.d.ts

@@ -0,0 +1 @@
+export declare function json(data: unknown, init?: ResponseInit): Response;

package/dist/server/json.js

@@ -0,0 +1,16 @@
+import * as devalue from 'devalue';
+export function json(data, init) {
+    const body = devalue.stringify(data);
+    const headers = new Headers(init?.headers);
+    if (!headers.has('content-length')) {
+        headers.set('content-length', encoder.encode(body).byteLength.toString());
+    }
+    if (!headers.has('content-type')) {
+        headers.set('content-type', 'application/json');
+    }
+    return new Response(body, {
+        ...init,
+        headers,
+    });
+}
+const encoder = new TextEncoder();

package/dist/server/parseFormData.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="@sveltejs/kit" />
+import z from 'zod';
+export declare function parseFormData<Type extends z.ZodRawShape>(requestOrFormData: Request | FormData, shaps: Type | Type[], validation?: z.SuperRefinement<z.objectOutputType<Type, z.ZodTypeAny>>): Promise<{
+    formData: FormData;
+    err: import("@sveltejs/kit").ActionFailure<{
+        issues: {
+            message: string;
+            path: (string | number)[];
+            code: "invalid_type" | "invalid_literal" | "unrecognized_keys" | "invalid_union" | "invalid_union_discriminator" | "invalid_enum_value" | "invalid_arguments" | "invalid_return_type" | "invalid_date" | "invalid_string" | "too_small" | "too_big" | "invalid_intersection_types" | "not_multiple_of" | "not_finite" | "custom";
+            received: string;
+            expected: string;
+            unionErrors: z.typeToFlattenedError<any, string>[] | undefined;
+        }[];
+    }>;
+    data?: undefined;
+} | {
+    data: { [k_1 in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<Type>, { [k in keyof z.baseObjectOutputType<Type>]: undefined extends z.baseObjectOutputType<Type>[k] ? never : k; }[keyof Type]>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<Type>, { [k_2 in keyof z.baseObjectOutputType<Type>]: undefined extends z.baseObjectOutputType<Type>[k_2] ? never : k_2; }[keyof Type]>[k_1]; };
+    formData: FormData;
+    err?: undefined;
+}>;

package/dist/server/parseFormData.js

@@ -0,0 +1,63 @@
+import z from 'zod';
+import { fail } from '@sveltejs/kit';
+export async function parseFormData(requestOrFormData, shaps, validation) {
+    const formData = requestOrFormData instanceof Request ? await requestOrFormData.formData() : requestOrFormData;
+    const [firstShap, ...unionShaps] = Array.isArray(shaps) ? shaps : [shaps];
+    const shema = z.object(firstShap).superRefine(validation || (() => { }));
+    unionShaps.forEach((shap) => shema.or(z.object(shap)));
+    const formDataFlateObject = Object.fromEntries(formData);
+    const formDataObject = flateToNeestedObject(formDataFlateObject);
+    const parsed = shema.safeParse(formDataObject);
+    if (parsed.success === false) {
+        const issueToPOJO = (issue) => ({
+            message: issue.message,
+            path: issue.path,
+            code: issue.code,
+            received: issue.received,
+            expected: issue.expected,
+            unionErrors: issue.unionErrors?.map((err) => err.flatten()),
+        });
+        const issues = parsed.error.issues.map(issueToPOJO);
+        return { formData, err: fail(400, { issues }) };
+    }
+    return { data: parsed.data, formData };
+}
+function flateToNeestedObject(flatObject) {
+    const obj = {};
+    Object.entries(flatObject).forEach(([key, value]) => {
+        set(obj, key, value);
+    });
+    return obj;
+}
+function set(obj, path, value) {
+    if (typeof path === 'number')
+        path = [path];
+    if (!path || path.length === 0)
+        return obj;
+    if (typeof path === 'string')
+        return set(obj, path.split('.').map(getKey), value);
+    const currentPath = path[0];
+    const currentValue = obj[currentPath];
+    if (path.length === 1) {
+        if (currentValue === undefined) {
+            obj[currentPath] = value;
+        }
+        return currentValue;
+    }
+    if (currentValue === undefined) {
+        //check if we assume an array
+        if (typeof path[1] === 'number') {
+            obj[currentPath] = [];
+        }
+        else {
+            obj[currentPath] = {};
+        }
+    }
+    return set(obj[currentPath], path.slice(1), value);
+}
+function getKey(key) {
+    const intKey = parseInt(key);
+    if (intKey.toString() === key)
+        return intKey;
+    return key;
+}

package/dist/server/parseQuery.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="@sveltejs/kit" />
+import type { ZodRawShape } from 'zod';
+export declare function parseQuery<Type extends ZodRawShape>(url: URL, shape: Type): {
+    err: import("@sveltejs/kit").ActionFailure<{
+        issues: import("zod").ZodIssue[];
+    }>;
+    data?: undefined;
+} | {
+    data: { [k_1 in keyof import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<Type>, { [k in keyof import("zod").baseObjectOutputType<Type>]: undefined extends import("zod").baseObjectOutputType<Type>[k] ? never : k; }[keyof Type]>]: import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<Type>, { [k_2 in keyof import("zod").baseObjectOutputType<Type>]: undefined extends import("zod").baseObjectOutputType<Type>[k_2] ? never : k_2; }[keyof Type]>[k_1]; };
+    err?: undefined;
+};

package/dist/server/parseQuery.js

@@ -0,0 +1,15 @@
+import { fail } from '@sveltejs/kit';
+import { z } from '../validation/zod.js';
+export function parseQuery(url, shape) {
+    const queryRaw = {};
+    Object.keys(shape).forEach((name) => {
+        const param = url.searchParams.get(name);
+        if (param)
+            queryRaw[name] = param;
+    });
+    const parsed = z.object(shape).safeParse(queryRaw);
+    if (parsed.success === false) {
+        return { err: fail(400, { issues: parsed.error.issues }) };
+    }
+    return { data: parsed.data };
+}

package/dist/server/sse.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import type { EventEmitter } from 'node:events';
+export declare function createSSE(last_id?: number, retry?: number): {
+    readable: ReadableStream<any>;
+    subscribe(eventEmitter: EventEmitter, event: string): Promise<void>;
+};

package/dist/server/sse.js

@@ -0,0 +1,35 @@
+// thanks: https://github.com/sveltejs/kit/issues/5344#issuecomment-1265286081
+export function createSSE(last_id = 0, retry = 0) {
+    let id = last_id;
+    const { readable, writable } = new TransformStream({
+        start(controller) {
+            controller.enqueue(': hello\n\n');
+            if (retry > 0)
+                controller.enqueue(`retry: ${retry}\n\n`);
+        },
+        transform({ event, data }, controller) {
+            let msg = `id: ${++id}\n`;
+            if (event)
+                msg += `event: ${event}\n`;
+            if (typeof data === 'string') {
+                msg += 'data: ' + data.trim().replace(/\n+/gm, '\ndata: ') + '\n';
+            }
+            else {
+                msg += `data: ${JSON.stringify(data)}\n`;
+            }
+            controller.enqueue(msg + '\n');
+        },
+    });
+    const writer = writable.getWriter();
+    return {
+        readable,
+        async subscribe(eventEmitter, event) {
+            function listener(data) {
+                writer.write({ event, data });
+            }
+            eventEmitter.on(event, listener);
+            await writer.closed.catch(() => { });
+            eventEmitter.off(event, listener);
+        },
+    };
+}

package/dist/server/try.d.ts

@@ -0,0 +1,6 @@
+import { type ActionFailure } from '@sveltejs/kit';
+export declare function tryOrFail<T = unknown>(fn: () => Promise<T>, 
+/** You can redirect on success */
+redirectTo?: string | ((res: T) => string)): Promise<T | ActionFailure<{
+    message: string;
+}>>;

package/dist/server/try.js

@@ -0,0 +1,31 @@
+import { fail, redirect } from '@sveltejs/kit';
+export async function tryOrFail(fn, 
+/** You can redirect on success */
+redirectTo) {
+    let result = null;
+    let isSuccess = false;
+    try {
+        result = await fn();
+        isSuccess = true;
+        return result;
+    }
+    catch (error) {
+        if ('status' in error && 'body' in error && 'message' in error.body) {
+            return fail(error.status, { message: error.body.message });
+        }
+        if ('meta' in error && error.meta && 'cause' in error.meta) {
+            return fail(400, { message: error.meta.cause });
+        }
+        const { message } = error;
+        return fail(400, { message });
+    }
+    finally {
+        if (isSuccess && redirectTo) {
+            if (typeof redirectTo === 'string')
+                redirect(302, redirectTo);
+            else if (result)
+                redirect(302, redirectTo(result));
+            console.warn('No result can be provide in redirectTo() function. Please use a simple string.');
+        }
+    }
+}

package/dist/store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isSmallScreen.js';
+export * from './param.js';

package/dist/store/index.js

@@ -0,0 +1,2 @@
+export * from './isSmallScreen.js';
+export * from './param.js';

package/dist/store/isSmallScreen.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="svelte" />
+export declare const isSmallScreen: import("svelte/store").Readable<boolean>;

package/dist/store/isSmallScreen.js

@@ -0,0 +1,14 @@
+import { browser } from '$app/environment';
+import { readable } from 'svelte/store';
+const getValue = () => browser && document.body.clientWidth < 600;
+export const isSmallScreen = readable(getValue(), (set) => {
+    if (!browser)
+        return;
+    const update = () => {
+        set(getValue());
+    };
+    window.addEventListener('resize', update);
+    return () => {
+        window.removeEventListener('resize', update);
+    };
+});

package/dist/store/param.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="svelte" />
+/// <reference types="@sveltejs/kit" />
+export declare const param: import("svelte/store").Readable<{
+    with: (params: Record<string, string | number>, ...keysToRemove: string[]) => string;
+    without: (...keys: string[]) => string;
+    toggle: (params: Record<string, string>, ...keysToRemove: string[]) => string;
+    /** Check if key exist in url params */
+    has: (key: string) => boolean;
+    get: (key: string) => string | null;
+    /** Check if value match in url params */
+    hasValue: (key: string, value: string) => boolean;
+    page: import("@sveltejs/kit").Page<Record<string, string>, string | null>;
+}>;
+export declare const urlParam: import("svelte/store").Readable<{
+    with: (params: Record<string, string | number>, ...keysToRemove: string[]) => string;
+    without: (...keys: string[]) => string;
+    toggle: (params: Record<string, string>, ...keysToRemove: string[]) => string;
+    /** Check if key exist in url params */
+    has: (key: string) => boolean;
+    get: (key: string) => string | null;
+    /** Check if value match in url params */
+    hasValue: (key: string, value: string) => boolean;
+    page: import("@sveltejs/kit").Page<Record<string, string>, string | null>;
+}>;

package/dist/store/param.js

@@ -0,0 +1,61 @@
+import { derived } from 'svelte/store';
+import { page } from '$app/stores';
+export const param = derived(page, (_page) => {
+    /** Return new url with new params */
+    const _with = (params, ...keysToRemove) => {
+        const url = new URL(_page.url);
+        Object.entries(params).forEach(([key, value]) => url.searchParams.set(key, String(value)));
+        keysToRemove.forEach((key) => url.searchParams.delete(key));
+        return url.search;
+    };
+    /** Return new url without params keys provided */
+    const without = (...keys) => {
+        const url = new URL(_page.url);
+        keys.forEach((key) => url.searchParams.delete(key));
+        return url.search;
+    };
+    /** Return new url with toggle params */
+    const toggle = (params, ...keysToRemove) => {
+        const url = new URL(_page.url);
+        Object.entries(params).forEach(([key, value]) => {
+            if (url.searchParams.get(key) === value)
+                url.searchParams.delete(key);
+            else
+                url.searchParams.set(key, value);
+        });
+        keysToRemove.forEach((key) => url.searchParams.delete(key));
+        return url.search;
+    };
+    return {
+        with: _with,
+        without,
+        toggle,
+        /** Check if key exist in url params */
+        has: (key) => _page.url.searchParams.has(key),
+        get: (key) => _page.url.searchParams.get(key),
+        /** Check if value match in url params */
+        hasValue: (key, value) => _page.url.searchParams.get(key) === value,
+        page: _page
+    };
+});
+export const urlParam = derived(param, (_param) => {
+    const { pathname } = _param.page.url;
+    /** Return new url with new params */
+    const _with = (params, ...keysToRemove) => {
+        return pathname + _param.with(params, ...keysToRemove);
+    };
+    /** Return new url without params keys provided */
+    const without = (...keys) => {
+        return pathname + _param.without(...keys);
+    };
+    /** Return new url with toggle params */
+    const toggle = (params, ...keysToRemove) => {
+        return pathname + _param.toggle(params, ...keysToRemove);
+    };
+    return {
+        ..._param,
+        with: _with,
+        without,
+        toggle
+    };
+});

package/dist/store/session.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="svelte" />
+export declare function sessionStore<T>(key: string, value: T): import("svelte/store").Writable<T>;

package/dist/store/session.js

@@ -0,0 +1,13 @@
+import { writable } from 'svelte/store';
+import { browser } from '$app/environment';
+import { jsonParse } from '../utils/index.js';
+export function sessionStore(key, value) {
+    if (!browser)
+        return writable(value);
+    const initialValue = jsonParse(sessionStorage.getItem(key), value);
+    const store = writable(initialValue);
+    store.subscribe((newValue) => {
+        sessionStorage.setItem(key, JSON.stringify(newValue));
+    });
+    return store;
+}

package/dist/ui/ButtonCopy.svelte

@@ -0,0 +1,18 @@
+<script>import { mdiClipboardTextOutline } from "@mdi/js";
+import { toast } from "svelte-sonner";
+import { Icon } from "./index.js";
+export let value;
+export let title;
+export let successMessage = "Copied";
+function handleClick() {
+  navigator.clipboard.writeText(value).then(() => {
+    toast.success(successMessage);
+  }).catch((error) => {
+    toast.error(error);
+  });
+}
+</script>
+
+<button on:click|preventDefault={handleClick} class="btn btn-square btn-ghost btn-sm">
+	<Icon path={mdiClipboardTextOutline} {title} size={22} />
+</button>

package/dist/ui/ButtonCopy.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        value: string;
+        title: string;
+        successMessage?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ButtonCopyProps = typeof __propDef.props;
+export type ButtonCopyEvents = typeof __propDef.events;
+export type ButtonCopySlots = typeof __propDef.slots;
+export default class ButtonCopy extends SvelteComponent<ButtonCopyProps, ButtonCopyEvents, ButtonCopySlots> {
+}
+export {};

package/dist/ui/ButtonDelete.svelte

@@ -0,0 +1,43 @@
+<script>let klass = "";
+export { klass as class };
+export let formaction;
+export let disabled = false;
+export let btn = true;
+let button;
+let width = 0;
+let ready = false;
+let timeout;
+function handleClick(event) {
+  if (ready)
+    return;
+  width = button.offsetWidth;
+  event.preventDefault();
+  ready = true;
+  timeout = setTimeout(() => ready = false, 2e3);
+}
+function handleLeave() {
+  ready = false;
+  clearTimeout(timeout);
+}
+</script>
+
+<button
+	bind:this={button}
+	class={klass}
+	class:btn
+	class:btn-error={btn && ready}
+	class:btn-outline={btn && ready}
+	class:text-error={btn && !ready}
+	class:btn-ghost={btn && !ready}
+	class:btn-disabled={disabled}
+	style:width={ready ? `${width}px` : ''}
+	on:click={handleClick}
+	on:mouseleave={handleLeave}
+	formaction={ready ? formaction : undefined}
+>
+	{#if ready}
+		<slot name="ready"><span>T'es sur ?</span></slot>
+	{:else}
+		<slot>Supprimer</slot>
+	{/if}
+</button>

package/dist/ui/ButtonDelete.svelte.d.ts

@@ -0,0 +1,22 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        class?: string | undefined;
+        formaction: string;
+        disabled?: boolean | undefined;
+        btn?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        ready: {};
+        default: {};
+    };
+};
+export type ButtonDeleteProps = typeof __propDef.props;
+export type ButtonDeleteEvents = typeof __propDef.events;
+export type ButtonDeleteSlots = typeof __propDef.slots;
+export default class ButtonDelete extends SvelteComponent<ButtonDeleteProps, ButtonDeleteEvents, ButtonDeleteSlots> {
+}
+export {};

package/dist/ui/Dialog.svelte

@@ -0,0 +1,58 @@
+<script>import { createEventDispatcher, onMount } from "svelte";
+import { mdiClose } from "@mdi/js";
+import { Icon } from "../index.js";
+export let dialog;
+export let hideCloseButton = false;
+let klass = "";
+export { klass as class };
+const dispatch = createEventDispatcher();
+onMount(() => {
+  const inputsSelector = 'input:not([type=hidden], [tabindex="-1"])';
+  const inputs = dialog.querySelectorAll(inputsSelector);
+  const buttons = dialog.querySelectorAll("button");
+  inputs.forEach((input) => input.tabIndex = -1);
+  buttons.forEach((button) => button.tabIndex = -1);
+  function onDialogOpen() {
+    dispatch("open");
+    inputs.forEach((input) => input.tabIndex = 0);
+    buttons.forEach((button) => button.tabIndex = 0);
+    if (!inputs[0])
+      return;
+    inputs[0].focus();
+    inputs[0].select();
+  }
+  function onDialogClose() {
+    dispatch("close");
+    inputs.forEach((input) => input.tabIndex = -1);
+    buttons.forEach((button) => button.tabIndex = -1);
+  }
+  const observer = new MutationObserver(() => dialog.open ? onDialogOpen() : onDialogClose());
+  observer.observe(dialog, { attributeFilter: ["open"] });
+  return () => observer.disconnect();
+});
+</script>
+
+<dialog bind:this={dialog} class="modal" tabindex="-1">
+	<div class="modal-box p-0 rounded-lg flex flex-col border bordered">
+		<div class="p-4 border-b flex relative items-center">
+			<div class="grow">
+				<slot name="header" />
+			</div>
+
+			{#if !hideCloseButton}
+				<button
+					type="button"
+					class="btn btn-square btn-ghost btn-sm ml"
+					on:click={() => dialog.close()}
+				>
+					<Icon path={mdiClose} />
+				</button>
+			{/if}
+		</div>
+		<div class="p-4 grow overflow-auto {klass}">
+			<slot />
+		</div>
+
+		<slot name="footer" />
+	</div>
+</dialog>

package/dist/ui/Dialog.svelte.d.ts

@@ -0,0 +1,25 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        dialog: HTMLDialogElement;
+        hideCloseButton?: boolean | undefined;
+        class?: string | undefined;
+    };
+    events: {
+        open: CustomEvent<void>;
+        close: CustomEvent<void>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        header: {};
+        default: {};
+        footer: {};
+    };
+};
+export type DialogProps = typeof __propDef.props;
+export type DialogEvents = typeof __propDef.events;
+export type DialogSlots = typeof __propDef.slots;
+export default class Dialog extends SvelteComponent<DialogProps, DialogEvents, DialogSlots> {
+}
+export {};