@fuzdev/fuz_ui 0.169.0

package/dist/contextmenu_state.svelte.js

@@ -0,0 +1,424 @@
+import { onDestroy } from 'svelte';
+import { is_promise } from '@fuzdev/fuz_util/async.js';
+import { BROWSER } from 'esm-env';
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.js';
+import { Dimensions } from './dimensions.svelte.js';
+import { create_context } from './context_helpers.js';
+import { url_to_root_relative } from './library_helpers.js';
+export class EntryState {
+    is_menu = false; // TODO rename to `type`?
+    menu;
+    run;
+    disabled;
+    selected = $state(false);
+    pending = $state(false);
+    error_message = $state(null);
+    promise = $state.raw(null);
+    constructor(menu, run, disabled = () => false) {
+        this.menu = menu;
+        this.run = run;
+        this.disabled = disabled;
+    }
+}
+export class SubmenuState {
+    is_menu = true;
+    menu;
+    depth;
+    selected = $state(false);
+    items = $state.raw([]);
+    constructor(menu, depth) {
+        this.menu = menu;
+        this.depth = depth;
+    }
+}
+export class RootMenuState {
+    is_menu = true;
+    menu = null;
+    depth = 1;
+    items = $state.raw([]);
+}
+/**
+ * Creates a `contextmenu` store.
+ * See usage with `ContextmenuRoot.svelte` and `Contextmenu.svelte`.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/contextmenu_event
+ */
+export class ContextmenuState {
+    layout; // TODO $state?
+    /**
+     * If an initial layout is provided, control is deferred externally.
+     * Otherwise the layout syncs to the page dimensions.
+     */
+    has_custom_layout;
+    // State for external consumers.
+    opened = $state(false);
+    x = $state(0);
+    y = $state(0);
+    params = $state.raw([]);
+    error = $state();
+    // These arrays use immutable updates (reassignment, not mutation).
+    // If you need reactivity, use `$contextmenu` in a reactive statement to react to all changes, and
+    // then access the immutable `contextmenu.root_menu` and `contextmenu.selections`.
+    // See `ContextmenuEntry.svelte` and `ContextmenuSubmenu.svelte` for reactive usage examples.
+    root_menu = new RootMenuState();
+    selections = $state.raw([]);
+    can_collapse = $derived(this.selections.length > 1);
+    can_expand = $derived.by(() => {
+        const selected = this.selections.at(-1);
+        return !!selected?.is_menu && selected.items.length > 0;
+    });
+    can_select_next = $derived.by(() => {
+        const menu = this.selections.at(-1)?.menu ?? this.root_menu;
+        return menu.items.length > 1;
+    });
+    can_select_previous = $derived.by(() => {
+        const menu = this.selections.at(-1)?.menu ?? this.root_menu;
+        return menu.items.length > 1;
+    });
+    can_activate = $derived.by(() => {
+        const selected = this.selections.at(-1);
+        if (!selected)
+            return false;
+        if (selected.is_menu)
+            return selected.items.length > 0;
+        return !selected.disabled();
+    });
+    constructor(options = EMPTY_OBJECT) {
+        const { layout } = options;
+        this.has_custom_layout = !!layout;
+        this.layout = layout ?? new Dimensions();
+    }
+    open(params, x, y) {
+        this.selections = [];
+        this.opened = true;
+        this.x = x;
+        this.y = y;
+        this.params = params;
+    }
+    close() {
+        if (!this.opened)
+            return;
+        this.reset_items(this.root_menu.items);
+        this.opened = false;
+    }
+    reset_items(items) {
+        for (const item of items) {
+            if (item.is_menu) {
+                this.reset_items(item.items);
+            }
+            else {
+                item.promise = null;
+                item.pending = false;
+                item.error_message = null;
+            }
+        }
+    }
+    activate(item) {
+        if (item.is_menu) {
+            this.expand_selected();
+        }
+        else {
+            if (item.disabled())
+                return false;
+            let returned;
+            try {
+                returned = item.run()();
+            }
+            catch (error) {
+                const message = typeof error?.message === 'string' ? error.message : undefined;
+                item.error_message = message ?? 'unknown error';
+                this.error = message;
+            }
+            if (is_promise(returned)) {
+                item.pending = true;
+                item.error_message = null;
+                const promise = (item.promise = returned
+                    .then((result) => {
+                    if (promise !== item.promise)
+                        return;
+                    if (typeof result?.ok === 'boolean') {
+                        if (result.ok) {
+                            if (result.close !== false) {
+                                this.close();
+                            }
+                        }
+                        else {
+                            const message = typeof result.message === 'string' ? result.message : undefined;
+                            item.error_message = message ?? 'unknown error';
+                            this.error = message;
+                        }
+                    }
+                    else {
+                        // void or undefined - default behavior is to close
+                        this.close();
+                    }
+                    return result;
+                }, (err) => {
+                    if (promise !== item.promise)
+                        return;
+                    const message = typeof err?.message === 'string' ? err.message : undefined;
+                    item.error_message = message ?? 'unknown error';
+                    this.error = message;
+                })
+                    .finally(() => {
+                    if (promise !== item.promise)
+                        return;
+                    item.pending = false;
+                    item.promise = null;
+                }));
+                return item.promise; // async path
+            }
+            // synchronous path
+            if (typeof returned?.ok === 'boolean') {
+                if (returned.ok) {
+                    if (returned.close !== false) {
+                        this.close();
+                    }
+                }
+                else {
+                    const message = typeof returned.message === 'string' ? returned.message : undefined;
+                    item.error_message = message ?? 'unknown error';
+                    this.error = message;
+                }
+            }
+            else {
+                // void or undefined - default behavior is to close
+                this.close();
+            }
+        }
+        return true;
+    }
+    activate_selected() {
+        const selected = this.selections.at(-1);
+        if (selected) {
+            return this.activate(selected);
+        }
+        this.select_first();
+    }
+    // Instead of diffing, this does the simple thing and
+    // deselects everything and then re-creates the list of selections.
+    // Could be improved but it's fine because we're using mutation and the N is very small,
+    // and it allows us to have a single code path for the various selection methods.
+    /**
+     * Activates the selected entry, or if none, selects the first.
+     */
+    // TODO implement focus management per APG: call .focus() on the selected item's DOM element (requires storing element refs in EntryState/SubmenuState)
+    select(item) {
+        if (this.selections.at(-1) === item)
+            return;
+        for (const s of this.selections)
+            s.selected = false;
+        const new_selections = [];
+        let i = item;
+        do {
+            i.selected = true;
+            new_selections.unshift(i);
+        } while ((i = i.menu) && i.menu); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+        this.selections = new_selections;
+    }
+    collapse_selected() {
+        if (!this.can_collapse)
+            return;
+        const deselected = this.selections.at(-1);
+        deselected.selected = false;
+        this.selections = this.selections.slice(0, -1);
+    }
+    expand_selected() {
+        if (!this.can_expand)
+            return;
+        const parent = this.selections.at(-1);
+        if (!parent?.is_menu || !parent.items.length)
+            return;
+        const selected = parent.items[0];
+        selected.selected = true;
+        this.selections = [...this.selections, selected];
+    }
+    select_next() {
+        if (!this.selections.length) {
+            this.select_first();
+            return;
+        }
+        const item = this.selections.at(-1);
+        const index = item.menu.items.indexOf(item);
+        this.select(item.menu.items[index === item.menu.items.length - 1 ? 0 : index + 1]);
+    }
+    select_previous() {
+        if (!this.selections.length) {
+            this.select_last();
+            return;
+        }
+        const item = this.selections.at(-1);
+        const index = item.menu.items.indexOf(item);
+        this.select(item.menu.items[index === 0 ? item.menu.items.length - 1 : index - 1]);
+    }
+    select_first() {
+        const menu = this.selections.at(-1)?.menu ?? this.root_menu;
+        if (!menu.items.length)
+            return;
+        this.select(menu.items[0]);
+    }
+    select_last() {
+        const { items } = this.selections.at(-1)?.menu ?? this.root_menu;
+        this.select(items.at(-1));
+    }
+    /**
+     * Used by `ContextmenuEntry` and custom entry components
+     * @initializes
+     */
+    add_entry(run, disabled = () => false) {
+        const menu = contextmenu_submenu_context.get_maybe() ?? this.root_menu;
+        const entry = new EntryState(menu, run, disabled);
+        menu.items = [...menu.items, entry];
+        // TODO messy, runs more than needed
+        onDestroy(() => {
+            menu.items = [];
+        });
+        return entry;
+    }
+    /**
+     * @initializes
+     */
+    add_submenu() {
+        const menu = contextmenu_submenu_context.get_maybe() ?? this.root_menu;
+        const submenu = new SubmenuState(menu, menu.depth + 1);
+        menu.items = [...menu.items, submenu];
+        contextmenu_submenu_context.set(submenu);
+        // TODO messy, runs more than needed
+        onDestroy(() => {
+            menu.items = [];
+        });
+        return submenu;
+    }
+}
+// The dataset key must not have capital letters or dashes or it'll differ between JS and DOM:
+// https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/dataset
+const CONTEXTMENU_DATASET_KEY = 'contextmenu';
+const CONTEXTMENU_DOM_QUERY = `a,[data-${CONTEXTMENU_DATASET_KEY}]`;
+const contextmenu_cache = new Map();
+let cache_key_counter = 0;
+/**
+ * Creates an attachment that sets up contextmenu behavior on an element.
+ * @param params Contextmenu parameters or nullish to disable
+ */
+export const contextmenu_attachment = (params) => (el) => {
+    // TODO could clean up the dataset attr, maybe use a weakmap?
+    if (params == null)
+        return;
+    // Only create key once per element, reuse on updates
+    let key = el.dataset[CONTEXTMENU_DATASET_KEY];
+    if (!key) {
+        key = cache_key_counter++ + '';
+        el.dataset[CONTEXTMENU_DATASET_KEY] = key;
+    }
+    contextmenu_cache.set(key, params);
+    return () => {
+        contextmenu_cache.delete(key);
+    };
+};
+const CONTEXTMENU_OPEN_VIBRATE_DURATION = 17;
+/**
+ * Opens the contextmenu, if appropriate,
+ * querying the menu items from the DOM starting at the event target.
+ * @param target the leaf element from which to open the contextmenu
+ * @param x the page X coordinate at which to open the contextmenu, typically the mouse `pageX`
+ * @param y the page Y coordinate at which to open the contextmenu, typically the mouse `pageY`
+ * @param contextmenu the contextmenu store
+ * @param options optional configuration for filtering entries and haptic feedback
+ * @returns a boolean indicating if the menu was opened or not
+ */
+export const contextmenu_open = (target, x, y, contextmenu, options) => {
+    const { link_enabled = true, text_enabled = true, separator_enabled = true, vibrate = true, } = options ?? EMPTY_OBJECT;
+    const params = contextmenu_query_params(target)?.filter((p) => typeof p === 'function' ||
+        ((p.snippet !== 'link' || link_enabled) &&
+            (p.snippet !== 'text' || text_enabled) &&
+            (p.snippet !== 'separator' || separator_enabled)));
+    // No-op if empty
+    if (!params?.length)
+        return false;
+    contextmenu.open(params, x, y);
+    // `navigator.vibrate()` works with `ContextmenuRoot` but gets blocked by some browsers
+    // when used with `ContextmenuRootForSafariCompatibility` because its longpress
+    // workaround triggers from a timeout rather than a direct user interaction.
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (BROWSER && vibrate && navigator.vibrate) {
+        navigator.vibrate(CONTEXTMENU_OPEN_VIBRATE_DURATION);
+    }
+    return true;
+};
+const contextmenu_query_params = (target) => {
+    let params = null;
+    // crawl DOM for contextmenu entries
+    let el = target;
+    let cache_key, cached;
+    while ((el = el?.closest(CONTEXTMENU_DOM_QUERY))) {
+        if ((cache_key = el.dataset[CONTEXTMENU_DATASET_KEY])) {
+            params ??= [];
+            cached = contextmenu_cache.get(cache_key);
+            if (cached === undefined) {
+                continue;
+            }
+            // preserve bubbling order
+            if (Array.isArray(cached)) {
+                (params ??= []).push(...cached);
+            }
+            else {
+                (params ??= []).push(cached);
+            }
+        }
+        if (el.tagName === 'A') {
+            (params ??= []).push({
+                snippet: 'link',
+                // anchor elements have the full url, but we want the slash-prefixed/absolute/root-relative version
+                props: { href: url_to_root_relative(el.href) },
+            });
+        }
+        el = el.parentElement;
+    }
+    // add "copy text" entry if anything is selected and we have any other entries
+    if (params) {
+        const text = window.getSelection()?.toString();
+        if (text) {
+            params.unshift({
+                snippet: 'text',
+                props: {
+                    content: 'copy text',
+                    icon: '📋',
+                    run: async () => {
+                        await navigator.clipboard.writeText(text);
+                    },
+                },
+            });
+        }
+    }
+    return params;
+};
+export const contextmenu_context = create_context();
+export const contextmenu_submenu_context = create_context();
+export const contextmenu_dimensions_context = create_context(() => new Dimensions());
+// Global registry of non-scoped contextmenu roots (only used in DEV)
+const non_scoped_roots = new Set();
+/**
+ * Registers a contextmenu root and warns if multiple non-scoped roots are detected.
+ * Only active in development mode. Automatically handles cleanup on unmount.
+ *
+ * @param get_scoped Getter function that returns the current scoped value
+ */
+export const contextmenu_check_global_root = (get_scoped) => {
+    $effect(() => {
+        const id = Symbol('contextmenu_root');
+        if (!get_scoped()) {
+            // Register as global (non-scoped)
+            non_scoped_roots.add(id);
+            if (non_scoped_roots.size > 1) {
+                // eslint-disable-next-line no-console
+                console.error(`Detected multiple non-scoped contextmenu roots (${non_scoped_roots.size} mounted). ` +
+                    'Only one global contextmenu root should be active at a time. ' +
+                    'Are you missing a `scoped` attribute?');
+            }
+        }
+        // Cleanup: unregister when scoped changes or component unmounts
+        return () => {
+            non_scoped_roots.delete(id);
+        };
+    });
+};

package/dist/csp.d.ts

@@ -0,0 +1,160 @@
+import type { ArrayElement, Defined } from '@fuzdev/fuz_util/types.js';
+export interface CreateCspDirectivesOptions {
+    /**
+     * Override or transform specific directives.
+     * Returning `null` or `undefined` from a transform function will remove the directive.
+     */
+    directives?: {
+        [K in CspDirective]?: CspDirectiveValue<K> | null | ((value: CspDirectiveValue<K>) => CspDirectiveValue<K> | null);
+    };
+    /**
+     * Sources to include based on their trust levels.
+     */
+    trusted_sources?: Array<CspSourceSpec>;
+    /**
+     * Override default values for specific directives,
+     * merging with `value_defaults_base` (or replacing if that directive is null in the base).
+     */
+    value_defaults?: Partial<typeof csp_directive_value_defaults>;
+    /**
+     * Base values for directive defaults.
+     * Set to `null` or `{}` to start with no defaults.
+     * Defaults to `csp_directive_value_defaults`.
+     */
+    value_defaults_base?: Partial<typeof csp_directive_value_defaults> | null;
+    /**
+     * Override trust requirements for specific directives,
+     * merging with `required_trust_defaults_base` (or replacing if that directive is null in the base).
+     */
+    required_trust_defaults?: Partial<typeof csp_directive_required_trust_defaults>;
+    /**
+     * Base values for directive trust requirements.
+     * Set to `null` or `{}` to start with no trust requirements.
+     * Defaults to `csp_directive_required_trust_defaults`.
+     */
+    required_trust_defaults_base?: Partial<typeof csp_directive_required_trust_defaults> | null;
+}
+/**
+ * This is designed for compatibility with SvelteKit
+ * and maps to the `KitConfig` `directives` option.
+ * The goal is to provide an ergonomic, modern, and safe API
+ * for Content Security Policy (CSP) creation
+ * that's simple to write and audit, and isn't error-prone.
+ *
+ * Things like validation and rendering to a string
+ * are out of scope and left to SvelteKit.
+ */
+export declare function create_csp_directives(options?: CreateCspDirectivesOptions): CspDirectives;
+export type CspDirective = keyof CspDirectives;
+export declare const parse_csp_directive: (directive: unknown) => CspDirective | null;
+export type CspDirectiveValue<T extends CspDirective> = Defined<CspDirectives[T]>;
+export declare const csp_trust_levels: readonly ["low", "medium", "high"];
+/**
+ * Numeric values for CSP trust levels, `csp_trust_levels`.
+ * Lower is less trusted.
+ * Includes `undefined` in the type for safety.
+ */
+export declare const csp_trust_level_value: Record<CspTrustLevel, number | undefined>;
+/**
+ * Trust levels for CSP sources.
+ *
+ * With the base defaults, trust levels roughly correspond to:
+ *
+ * - `low` – Passive resources only (no script execution, no styling or UI control).
+ * 		Examples: `img-src`, `font-src`.
+ * - `medium` – Content that may affect layout, styling, or embed external browsing contexts,
+ *    but cannot directly run code in the page's JS execution environment or
+ * 		perform other high-risk actions. Examples: `style-src`, `frame-src`, `frame-ancestors`.
+ * - `high` – Sources that can execute code in the page's context or open powerful network
+ *    channels. Examples: `script-src`, `connect-src`, `child-src`.
+ * - `null` – No trust. This is used for directives that don't support sources.
+ *
+ */
+export type CspTrustLevel = ArrayElement<typeof csp_trust_levels>;
+/**
+ * Validates and extracts a CSP trust level from an unknown value.
+ */
+export declare const parse_csp_trust_level: (trust: unknown) => CspTrustLevel | null;
+export interface CspSourceSpec {
+    source: CspSource;
+    trust?: CspTrustLevel;
+    directives?: Array<CspDirective>;
+}
+export interface CspDirectiveSpec {
+    name: CspDirective;
+    fallback: Array<CspDirective> | null;
+    fallback_of: Array<CspDirective> | null;
+}
+/**
+ * Determines if a granted trust level is sufficient to satisfy a required trust level.
+ *
+ * Trust levels have the following hierarchy:
+ * - 'high' sources can be used in high, medium, and low trust directives (highest privilege)
+ * - 'medium' sources can be used in medium and low trust directives
+ * - 'low' sources can only be used in low trust directives (lowest privilege)
+ */
+export declare const is_csp_trusted: (required_trust: CspTrustLevel | null | undefined, granted_trust: CspTrustLevel | null | undefined) => boolean;
+export declare const COLOR_SCHEME_SCRIPT_HASH = "sha256-QOxqn7EUzb3ydF9SALJoJGWSvywW9R0AfTDSenB83Z8=";
+/**
+ * The base CSP directive defaults.
+ * Prioritizes safety but loosens around media and styles, relying on defense-in-depth.
+ * Customizable via `CreateCspDirectivesOptions.defaults`.
+ */
+export declare const csp_directive_value_defaults: Record<CspDirective, CspDirectiveValue<CspDirective> | null>;
+/**
+ * Sources that meet this trust requirement are included for it by default.
+ * If null, no trusted sources are added to the directive automatically.
+ * Directives that don't support sources or default to `['none']` are null.
+ *
+ * Feedback is welcome, please see the issues - https://github.com/ryanatkn/fuz/issues
+ */
+export declare const csp_directive_required_trust_defaults: Record<CspDirective, CspTrustLevel | null>;
+/**
+ * Static data descriptors for the CSP directives.
+ * Fuz excludes deprecated directives, so those are intentionally omitted,
+ * but any newer missing directives are bugs.
+ *
+ * Could be moved to `csp.ts` but is currently here to keep that module smaller.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Content-Security-Policy
+ */
+export declare const csp_directive_specs: Array<CspDirectiveSpec>;
+export declare const csp_directive_spec_by_name: Map<CspDirective, CspDirectiveSpec>;
+export type CspActionSource = 'strict-dynamic' | 'report-sample';
+export type CspBaseSource = 'self' | 'unsafe-eval' | 'unsafe-hashes' | 'unsafe-inline' | 'wasm-unsafe-eval' | 'none';
+export type CspCryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`;
+export type CspFrameSource = CspHostSource | CspSchemeSource | 'self' | 'none';
+export type CspHostNameScheme = `${string}.${string}` | 'localhost';
+export type CspHostSource = `${CspHostProtocolSchemes}${CspHostNameScheme}${CspPortScheme}`;
+export type CspHostProtocolSchemes = `${string}://` | '';
+export type CspPortScheme = `:${number}` | '' | ':*';
+export type CspSchemeSource = 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:';
+export type CspSource = CspHostSource | CspSchemeSource | CspCryptoSource | CspBaseSource;
+export type CspSources = Array<CspSource>;
+export interface CspDirectives {
+    'default-src'?: Array<CspSource | CspActionSource>;
+    'script-src'?: Array<CspSource | CspActionSource>;
+    'script-src-elem'?: CspSources;
+    'script-src-attr'?: CspSources;
+    'style-src'?: Array<CspSource | CspActionSource>;
+    'style-src-elem'?: CspSources;
+    'style-src-attr'?: CspSources;
+    'img-src'?: CspSources;
+    'media-src'?: CspSources;
+    'font-src'?: CspSources;
+    'manifest-src'?: CspSources;
+    'child-src'?: CspSources;
+    'connect-src'?: CspSources;
+    'frame-src'?: CspSources;
+    'frame-ancestors'?: Array<CspFrameSource>;
+    'form-action'?: Array<CspSource | CspActionSource>;
+    'worker-src'?: CspSources;
+    'object-src'?: CspSources;
+    'base-uri'?: Array<CspSource | CspActionSource>;
+    'upgrade-insecure-requests'?: boolean;
+    'report-to'?: Array<string>;
+    'require-trusted-types-for'?: Array<'script'>;
+    'trusted-types'?: Array<'none' | 'allow-duplicates' | '*' | string>;
+    sandbox?: Array<'allow-downloads-without-user-activation' | 'allow-forms' | 'allow-modals' | 'allow-orientation-lock' | 'allow-pointer-lock' | 'allow-popups' | 'allow-popups-to-escape-sandbox' | 'allow-presentation' | 'allow-same-origin' | 'allow-scripts' | 'allow-storage-access-by-user-activation' | 'allow-top-navigation' | 'allow-top-navigation-by-user-activation'>;
+}
+//# sourceMappingURL=csp.d.ts.map

package/dist/csp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csp.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/csp.ts"],"names":[],"mappings":"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"}