fuma 0.0.1

package/dist/ui/table/head/TableHeadNumber.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponent } from "svelte";
+import type { TableField } from '../field.js';
+declare const __propDef: {
+    props: {
+        field: TableField;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TableHeadNumberProps = typeof __propDef.props;
+export type TableHeadNumberEvents = typeof __propDef.events;
+export type TableHeadNumberSlots = typeof __propDef.slots;
+export default class TableHeadNumber extends SvelteComponent<TableHeadNumberProps, TableHeadNumberEvents, TableHeadNumberSlots> {
+}
+export {};

package/dist/ui/table/head/TableHeadSelect.svelte

@@ -0,0 +1,75 @@
+<script>import { derived } from "svelte/store";
+import { page } from "$app/stores";
+import { jsonParse } from "../../../utils/jsonParse.js";
+import { DropDown, Icon } from "../../index.js";
+import { parseOptions } from "../../../utils/options.js";
+import { urlParam } from "../../../store/param.js";
+export let field;
+export let options;
+export let multiSelect = false;
+let _options = initOptions($page.url);
+page.subscribe(({ url }) => _options = initOptions(url));
+function initOptions({ searchParams }) {
+  const selection = searchParams.get(field.key);
+  const selections = jsonParse(searchParams.get(field.key), []);
+  function getActive(value) {
+    if (!multiSelect)
+      return selection === value;
+    return selections.includes(value);
+  }
+  return parseOptions(options).map((option) => ({
+    ...option,
+    isActive: getActive(option.value)
+  }));
+}
+const getHref = derived(urlParam, (params) => (value) => {
+  const selections = jsonParse(params.get(field.key), []);
+  if (!multiSelect)
+    return params.toggle({ [field.key]: value }, "skip", "take");
+  if (selections.includes(value)) {
+    const newSelections = selections.filter((v) => v !== value);
+    if (!newSelections.length)
+      return params.without(field.key);
+    return params.with({ [field.key]: JSON.stringify(newSelections) }, "skip", "take");
+  }
+  return params.with({ [field.key]: JSON.stringify([...selections, value]) }, "skip", "take");
+});
+</script>
+
+<th class="p-1">
+	<DropDown hideOnBlur hideOnNav={!multiSelect} tippyProps={{ appendTo: () => document.body }}>
+		<button slot="activator" class="menu-item min-h-8 w-full flex-wrap gap-y-1">
+			<span>{field.label}</span>
+
+			{#if _options.filter((option) => option.isActive).length}
+				<div class="flex flex-wrap gap-1">
+					{#each _options.filter((option) => option.isActive) as option}
+						<span class="badge badge-primary badge-xs text-[0.7rem] font-normal text-white">
+							{#if option.icon}
+								<Icon path={option.icon} size={10} class="-translate-x-1 fill-white/80" />
+							{/if}
+							{option.label}
+						</span>
+					{/each}
+				</div>
+			{/if}
+		</button>
+
+		<div class="flex flex-col gap-1">
+			{#each _options as { isActive, icon, label, value }}
+				<a
+					href={$getHref(value)}
+					class="menu-item px-3 py-2"
+					class:active={isActive}
+					data-sveltekit-noscroll
+					data-sveltekit-replacestate
+				>
+					{#if icon}
+						<Icon path={icon} size={18} class="opacity-60" />
+					{/if}
+					<span class="whitespace-nowrap font-normal">{label}</span>
+				</a>
+			{/each}
+		</div>
+	</DropDown>
+</th>

package/dist/ui/table/head/TableHeadSelect.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponent } from "svelte";
+import { type TableField } from '../../index.js';
+import { type Options } from '../../../utils/options.js';
+declare const __propDef: {
+    props: {
+        field: TableField;
+        options: Options;
+        multiSelect?: boolean | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TableHeadSelectProps = typeof __propDef.props;
+export type TableHeadSelectEvents = typeof __propDef.events;
+export type TableHeadSelectSlots = typeof __propDef.slots;
+export default class TableHeadSelect extends SvelteComponent<TableHeadSelectProps, TableHeadSelectEvents, TableHeadSelectSlots> {
+}
+export {};

package/dist/ui/table/head/TableHeadString.svelte

@@ -0,0 +1,35 @@
+<script>import { mdiMagnify } from "@mdi/js";
+import { page } from "$app/stores";
+import { DropDown, Icon, InputSearch } from "../../index.js";
+export let field;
+let tip;
+let searchValue = $page.url.searchParams.get(field.key) || "";
+</script>
+
+<th class="p-1">
+	<DropDown
+		bind:tip
+		hideOnBlur
+		hideOnNav={false}
+		autofocus
+		tippyProps={{ appendTo: () => document.body }}
+	>
+		<button slot="activator" class="menu-item min-h-8 w-full flex-wrap gap-y-1">
+			<span>{field.label}</span>
+
+			{#if searchValue}
+				<span class="badge badge-primary badge-xs text-[0.7rem] font-normal text-white">
+					<Icon path={mdiMagnify} size={10} class="-translate-x-1 fill-white/80" />
+					<span>{searchValue}</span>
+				</span>
+			{/if}
+		</button>
+
+		<InputSearch
+			class="m-1"
+			key={field.key}
+			bind:value={searchValue}
+			on:keydown={(e) => e.key === 'Enter' && tip.hide()}
+		/>
+	</DropDown>
+</th>

package/dist/ui/table/head/TableHeadString.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponent } from "svelte";
+import { type TableField } from '../../index.js';
+declare const __propDef: {
+    props: {
+        field: TableField;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TableHeadStringProps = typeof __propDef.props;
+export type TableHeadStringEvents = typeof __propDef.events;
+export type TableHeadStringSlots = typeof __propDef.slots;
+export default class TableHeadString extends SvelteComponent<TableHeadStringProps, TableHeadStringEvents, TableHeadStringSlots> {
+}
+export {};

package/dist/ui/table/head/index.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentProps } from 'svelte';
+import type { ComponentAndProps } from '../../../utils/component.js';
+import type { TableField, TableFieldType } from '../field.js';
+import { default as TableHeadSelect } from './TableHeadSelect.svelte';
+import { default as TableHeadDate } from './TableHeadDate.svelte';
+import { default as TableHeadBoolean } from './TableHeadBoolean.svelte';
+import { default as TableHeadNumber } from './TableHeadNumber.svelte';
+import { default as TableHeadString } from './TableHeadString.svelte';
+declare const tableHeadComponentRecord: {
+    boolean: typeof TableHeadBoolean;
+    string: typeof TableHeadString;
+    textarea: typeof TableHeadString;
+    number: typeof TableHeadNumber;
+    multiselect: typeof TableHeadSelect;
+    select: typeof TableHeadSelect;
+    date: typeof TableHeadDate;
+};
+export declare function tableHeadComponent<T extends TableFieldType>(type: T, props: Omit<ComponentProps<InstanceType<(typeof tableHeadComponentRecord)[T]>>, 'field'>): (field: TableField) => ComponentAndProps;
+export {};

package/dist/ui/table/head/index.js

@@ -0,0 +1,22 @@
+import { default as TableHeadSelect } from './TableHeadSelect.svelte';
+import { default as TableHeadDate } from './TableHeadDate.svelte';
+import { default as TableHeadBoolean } from './TableHeadBoolean.svelte';
+import { default as TableHeadNumber } from './TableHeadNumber.svelte';
+import { default as TableHeadString } from './TableHeadString.svelte';
+const tableHeadComponentRecord = {
+    boolean: TableHeadBoolean,
+    string: TableHeadString,
+    textarea: TableHeadString,
+    number: TableHeadNumber,
+    multiselect: TableHeadSelect,
+    select: TableHeadSelect,
+    date: TableHeadDate
+};
+export function tableHeadComponent(type, props) {
+    return (field) => {
+        const component = tableHeadComponentRecord[type];
+        if (type !== 'multiselect')
+            return { component, props: { ...props, field } };
+        return { component, props: { ...props, field, multiSelect: true } };
+    };
+}

package/dist/ui/table/index.d.ts

@@ -0,0 +1,10 @@
+export { type TableField } from './field.js';
+export { default as Table } from './Table.svelte';
+export { default as TableHead } from './TableHead.svelte';
+export { default as TableBody } from './TableBody.svelte';
+export { default as TableCell } from './TableCell.svelte';
+export { default as TableFieldsEdition } from './TableFieldsEdition.svelte';
+export { default as TableViewSelect } from './TableViewSelect.svelte';
+export * from './head/index.js';
+export * from './field.js';
+export * from './context.js';

package/dist/ui/table/index.js

@@ -0,0 +1,10 @@
+export {} from './field.js';
+export { default as Table } from './Table.svelte';
+export { default as TableHead } from './TableHead.svelte';
+export { default as TableBody } from './TableBody.svelte';
+export { default as TableCell } from './TableCell.svelte';
+export { default as TableFieldsEdition } from './TableFieldsEdition.svelte';
+export { default as TableViewSelect } from './TableViewSelect.svelte';
+export * from './head/index.js';
+export * from './field.js';
+export * from './context.js';

package/dist/ui/table/server.d.ts

@@ -0,0 +1 @@
+export declare function ensureFieldsWithFilterAreVisibles(tableKey: string, url: URL, isFilterKey: (key: string) => boolean): void;

package/dist/ui/table/server.js

@@ -0,0 +1,32 @@
+import { redirect } from '@sveltejs/kit';
+import { jsonParse } from '../../utils/jsonParse.js';
+import { createKeys } from './context.js';
+export function ensureFieldsWithFilterAreVisibles(tableKey, url, isFilterKey) {
+    const { KEY_FIELDS_VISIBLE, KEY_FIELDS_HIDDEN } = createKeys(tableKey);
+    const fieldsVisible = jsonParse(url.searchParams.get(KEY_FIELDS_VISIBLE), []);
+    const fieldsHidden = jsonParse(url.searchParams.get(KEY_FIELDS_HIDDEN), []);
+    // Ensure all existing filter is visible
+    const _fieldsVisible = [...fieldsVisible];
+    const _fieldsHidden = [...fieldsHidden];
+    for (const key of url.searchParams.keys()) {
+        if (!isFilterKey(key))
+            continue;
+        if (!_fieldsVisible.includes(key))
+            _fieldsVisible.push(key);
+        if (_fieldsHidden.includes(key))
+            _fieldsHidden.splice(_fieldsHidden.indexOf(key), 1);
+    }
+    const paramsUpdated = _fieldsVisible.length !== fieldsVisible.length || _fieldsHidden.length !== fieldsHidden.length;
+    if (!paramsUpdated)
+        return;
+    const _url = new URL(url);
+    if (!_fieldsVisible.length)
+        _url.searchParams.delete(KEY_FIELDS_VISIBLE);
+    else
+        _url.searchParams.set(KEY_FIELDS_VISIBLE, JSON.stringify(_fieldsVisible));
+    if (!_fieldsHidden.length)
+        _url.searchParams.delete(KEY_FIELDS_HIDDEN);
+    else
+        _url.searchParams.set(KEY_FIELDS_HIDDEN, JSON.stringify(_fieldsHidden));
+    redirect(302, _url);
+}

package/dist/ui/tabs/Tabs.svelte

@@ -0,0 +1,28 @@
+<script>import { page } from "$app/stores";
+import { Icon } from "../../index.js";
+export let tabs;
+let klass = "";
+export { klass as class };
+</script>
+
+<div
+	class="
+	bordered sticky top-0 z-20 flex gap-2 rounded-t-2xl border-b bg-base-100 p-2 shadow-sm
+	{klass}
+	"
+>
+	{#each tabs as tab}
+		{@const active = tab.isActive ?? $page.url.pathname.startsWith(tab.href)}
+		<a
+			href={tab.href}
+			class="
+        menu-item grow flex-col justify-center gap-0 rounded-lg py-2
+        text-sm lg:flex-row lg:gap-3 lg:text-base
+      "
+			class:active
+		>
+			<Icon path={tab.icon} size={20} class="opacity-70" />
+			<span class="hidden whitespace-nowrap sm:block">{tab.label}</span>
+		</a>
+	{/each}
+</div>

package/dist/ui/tabs/Tabs.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+import type { Tab } from './index.js';
+declare const __propDef: {
+    props: {
+        tabs: Tab[];
+        class?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TabsProps = typeof __propDef.props;
+export type TabsEvents = typeof __propDef.events;
+export type TabsSlots = typeof __propDef.slots;
+export default class Tabs extends SvelteComponent<TabsProps, TabsEvents, TabsSlots> {
+}
+export {};

package/dist/ui/tabs/TabsIcon.svelte

@@ -0,0 +1,56 @@
+<script>import { page } from "$app/stores";
+import { onMount } from "svelte";
+import { urlParam } from "../../store/index.js";
+import { Icon, parseOptions } from "../../index.js";
+export let options;
+export let showLabel = false;
+export let key;
+export let defaultValue = void 0;
+let _options = getOptions($page.url);
+onMount(
+  () => page.subscribe(({ url }) => {
+    _options = getOptions(url);
+  })
+);
+function getOptions(url) {
+  return parseOptions(options).map((option) => ({
+    ...option,
+    isActive: getIsActive(option, url)
+  }));
+}
+function getIsActive(option, { searchParams }) {
+  if (searchParams.get(key) === option.value)
+    return true;
+  if (!searchParams.has(key))
+    return option.value === defaultValue;
+  return false;
+}
+</script>
+
+<div class="flex items-center gap-[3px] rounded-lg bg-base-200 p-1">
+	{#each _options as { value, label, icon, isActive }}
+		<a
+			href={$urlParam.with({ [key]: value })}
+			data-sveltekit-noscroll
+			data-sveltekit-replacestate
+			class="flex h-6 items-center justify-center gap-2 rounded p-1"
+			class:px-2={showLabel}
+			class:w-6={icon && !showLabel}
+			class:whitespace-nowrap={showLabel}
+			class:bg-base-100={isActive}
+			class:shadow={isActive}
+		>
+			{#if icon}
+				<Icon
+					path={icon}
+					title={showLabel ? '' : label}
+					size={18}
+					class={isActive ? '' : 'opacity-60'}
+				/>
+			{/if}
+			{#if !icon || showLabel}
+				<span class="text-sm font-medium opacity-80">{label}</span>
+			{/if}
+		</a>
+	{/each}
+</div>

package/dist/ui/tabs/TabsIcon.svelte.d.ts

@@ -0,0 +1,20 @@
+import { SvelteComponent } from "svelte";
+import { type Options } from '../../index.js';
+declare const __propDef: {
+    props: {
+        options: Options;
+        showLabel?: boolean | undefined;
+        key: string;
+        defaultValue?: string | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TabsIconProps = typeof __propDef.props;
+export type TabsIconEvents = typeof __propDef.events;
+export type TabsIconSlots = typeof __propDef.slots;
+export default class TabsIcon extends SvelteComponent<TabsIconProps, TabsIconEvents, TabsIconSlots> {
+}
+export {};

package/dist/ui/tabs/index.d.ts

@@ -0,0 +1,8 @@
+export { default as Tabs } from './Tabs.svelte';
+export { default as TabsIcon } from './TabsIcon.svelte';
+export type Tab = {
+    href: string;
+    isActive?: boolean;
+    label: string;
+    icon: string;
+};

package/dist/ui/tabs/index.js

@@ -0,0 +1,2 @@
+export { default as Tabs } from './Tabs.svelte';
+export { default as TabsIcon } from './TabsIcon.svelte';

package/dist/utils/avatar.d.ts

@@ -0,0 +1 @@
+export declare function createAvatarPlaceholder(): string;

package/dist/utils/avatar.js

@@ -0,0 +1,5 @@
+export function createAvatarPlaceholder() {
+    const avatarUrl = new URL('https://api.dicebear.com/7.x/thumbs/svg');
+    avatarUrl.searchParams.append('seed', String(Math.random()));
+    return avatarUrl.toString();
+}

package/dist/utils/component.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps, ComponentType } from 'svelte';
+export type Primitive = string | number | boolean;
+export type ComponentAndProps = {
+    component: ComponentType;
+    props: ComponentProps<InstanceType<ComponentType>>;
+};
+export declare function component<Component extends ComponentType>(component: Component, props: ComponentProps<InstanceType<Component>>): ComponentAndProps;

package/dist/utils/component.js

@@ -0,0 +1,3 @@
+export function component(component, props) {
+    return { component, props };
+}

package/dist/utils/formatRange.d.ts

@@ -0,0 +1,8 @@
+type Range = {
+    start: Date | number;
+    end: Date | number;
+};
+export declare const formatRange: ({ start, end }: Range) => string;
+export declare const formatRangeShort: ({ start, end }: Range) => string;
+export declare const formatRangeHour: ({ start, end }: Range) => string;
+export {};

package/dist/utils/formatRange.js

@@ -0,0 +1,25 @@
+import dayjs from 'dayjs';
+const formater = new Intl.DateTimeFormat('fr-ch', {
+    weekday: 'long',
+    day: 'numeric',
+    month: 'numeric',
+    year: '2-digit',
+    hour: 'numeric',
+    minute: 'numeric',
+    timeZone: 'Europe/Zurich',
+});
+const formaterShort = new Intl.DateTimeFormat('fr-ch', {
+    weekday: 'short',
+    hour: 'numeric',
+    minute: 'numeric',
+    timeZone: 'Europe/Zurich',
+});
+export const formatRange = ({ start, end }) => formater.formatRange(start, end);
+export const formatRangeShort = ({ start, end }) => formaterShort.formatRange(start, end);
+export const formatRangeHour = ({ start, end }) => {
+    const _start = dayjs(start);
+    const _end = dayjs(end);
+    if (_start.isSame(_end))
+        return _start.format('HH:mm');
+    return [_start.format('HH:mm'), _end.format('HH:mm')].join(' – ');
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './component.js';
+export * from './jsonParse.js';
+export * from './normalizePath.js';
+export * from './formatRange.js';
+export * from './options.js';
+export * from './avatar.js';
+export * from './tippy.js';

package/dist/utils/index.js

@@ -0,0 +1,7 @@
+export * from './component.js';
+export * from './jsonParse.js';
+export * from './normalizePath.js';
+export * from './formatRange.js';
+export * from './options.js';
+export * from './avatar.js';
+export * from './tippy.js';

package/dist/utils/jsonParse.d.ts

@@ -0,0 +1 @@
+export declare function jsonParse<Type>(text: string | null | undefined, defaultValue: Type): Type;

package/dist/utils/jsonParse.js

@@ -0,0 +1,10 @@
+export function jsonParse(text, defaultValue) {
+    try {
+        if (!text)
+            return defaultValue;
+        return JSON.parse(text);
+    }
+    catch {
+        return defaultValue;
+    }
+}

package/dist/utils/normalizePath.d.ts

@@ -0,0 +1 @@
+export declare function normalizePath(str: string | undefined): string;

package/dist/utils/normalizePath.js

@@ -0,0 +1,11 @@
+export function normalizePath(str) {
+    if (!str)
+        return '';
+    return str
+        .trim()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replaceAll(' ', '-')
+        .replace(/[\.\:\/\?\#\[\]\@\!\$\&\'\(\)\*\+\,\;\=]/g, '')
+        .toLowerCase();
+}

package/dist/utils/options.d.ts

@@ -0,0 +1,7 @@
+export type Option = {
+    value: string;
+    label: string;
+    icon?: string;
+};
+export type Options = string | string[] | Option[] | Record<string, string> | Record<string, Omit<Option, 'value'>>;
+export declare function parseOptions(options: Options): Option[];

package/dist/utils/options.js

@@ -0,0 +1,20 @@
+import { jsonParse } from './jsonParse.js';
+export function parseOptions(options) {
+    if (typeof options === 'string') {
+        options = jsonParse(options, []);
+    }
+    if (Array.isArray(options)) {
+        return options.filter(Boolean).map((opt) => {
+            if (typeof opt === 'string')
+                return { value: opt, label: opt };
+            return opt;
+        });
+    }
+    return Object.entries(options)
+        .filter(([value]) => !!value)
+        .map(([value, opt]) => {
+        if (typeof opt === 'string')
+            return { value, label: opt };
+        return { value, ...opt };
+    });
+}

package/dist/utils/tippy.d.ts

@@ -0,0 +1,5 @@
+import 'tippy.js/dist/tippy.css';
+import { type Tippy, type Props as TippyProps, type Instance as TippyInstance, hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow } from 'tippy.js';
+export declare const tippy: Tippy<TippyProps>;
+export type { TippyProps, TippyInstance };
+export { hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow };

package/dist/utils/tippy.js

@@ -0,0 +1,4 @@
+import 'tippy.js/dist/tippy.css';
+import tippyBadTyped, { hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow } from 'tippy.js';
+export const tippy = tippyBadTyped;
+export { hideAll, delegate, createSingleton, animateFill, followCursor, inlinePositioning, sticky, roundArrow };

package/dist/validation/form.d.ts

@@ -0,0 +1,31 @@
+import type { SubmitFunction } from '@sveltejs/kit';
+export type SetError = {
+    [key: string]: (err: string) => void;
+};
+export type FormContext = {
+    setError: SetError;
+};
+export declare const formContext: {
+    get: () => FormContext;
+};
+type SuccessMessage = false | string | ((action: URL) => string);
+type BooleanOrFunction = boolean | ((action: URL) => boolean);
+type UseFormOptions<ReturnData> = {
+    onSubmit?: (...args: Parameters<SubmitFunction>) => any;
+    onSuccess?: (action: URL, data?: ReturnData) => any;
+    onResetError?: () => unknown;
+    onError?: (err: any) => unknown;
+    onFail?: (failure: Record<string, any> | undefined) => unknown;
+    successUpdate?: BooleanOrFunction;
+    successReset?: BooleanOrFunction;
+    successMessage?: SuccessMessage;
+};
+export declare function useForm<ReturnData extends Record<string, unknown>>({ onSubmit, onSuccess, onResetError, onError, onFail, successUpdate, successReset, successMessage }?: UseFormOptions<ReturnData>): {
+    enhance: (form: HTMLFormElement) => {
+        destroy(): void;
+    };
+    submit: SubmitFunction<ReturnData>;
+    resetErrors: () => void;
+    setError(key: string, value: string): void;
+};
+export {};