@torpor/ui 0.2.1 → 0.3.0

package/dist/Contextual/Contextual.torp

@@ -0,0 +1,125 @@
+import { ContextualContextName, type Point, type ContextualContext, type ContextualState } from "./ContextualTypes";
+
+interface ContextualProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Class name(s) for the root element */
+	class?: string,
+	/** Whether the contextual is modal. If true, an overlay should be supplied to obscure outside content, and only the context content will be visible to screen readers  */
+	modal?: boolean,
+	/** Whether the contextual is visible  */
+	visible?: boolean,
+	/** The element to anchor this contextual to, as an alternative to supplying a ContextualTrigger  */
+	anchor?: HTMLElement,
+	/** The position to display this contextual at  */
+	position?: Point,
+	/** A function to be called when the user selects a response */
+	callback?: ((value: any) => void),
+	/** Raised when this contextual is opened or closed */
+	ontoggle?: (open: boolean) => void,
+	/** Raised when the contextual has opened */
+	onopen?: () => void,
+	/** Raised when the contextual has closed */
+	onclose?: (result: any) => void,
+}
+
+/**
+ * A contextual window that is shown to the user at the cursor's location.
+ *
+ * The structure of a Contextual is:
+ *
+ * ```
+ * <Contextual>
+ * 	<ContextualTrigger /> (optional)
+ * 	<ContextualContent />
+ * </Contextual>
+ * ```
+ */
+export default function Contextual($props: ContextualProps | undefined) {
+	let $state: ContextualState = $watch({
+		visible: false,
+		position: { x: 0, y: 0 }
+	})
+
+	// Sync props and state
+	$run(() => {
+		$state.visible = $props?.visible ?? false;
+		$state.position = $props?.position ?? { x: 0, y: 0 };
+	});
+	$run(() => {
+		if ($props !== undefined) {
+			$props.visible = $state.visible;
+		}
+	});
+
+	let result: any;
+
+	// Set the context to pass down to items
+	let context: ContextualContext = {
+		handleButton,
+		handleClickOutside,
+		state: $state,
+		modal: $props?.modal,
+		anchorElement: $props?.anchor ? $unwrap($props.anchor) : undefined,
+	};
+	$context[ContextualContextName] = context;
+
+	// Dispatch the toggle event when the contextual is opened or closed
+	let firstToggle = true;
+	$run(() => {
+		const ontoggle = $props?.ontoggle;
+		const onopen = $props?.onopen;
+		const onclose = $props?.onclose;
+		const visible = $state.visible;
+		if (firstToggle) {
+			firstToggle = false;
+		} else {
+			if (ontoggle) ontoggle(visible);
+			if (visible) {
+				if (onopen) onopen()
+			} else {
+				if (onclose) onclose(result);
+			}
+		}
+	});
+
+	function handleButton(type: "confirm" | "cancel" | undefined, value?: any) {
+		// Get the button's result
+		switch (type) {
+			case "confirm": {
+				result = value || true;
+				break;
+			}
+			case "cancel": {
+				result = value || false;
+				break;
+			}
+			default: {
+				result = value;
+				break;
+			}
+		}
+
+		// Hide the contextual
+		$state.visible = false;
+
+		// Call the callback
+		if ($props?.callback) {
+			$props.callback(result);
+		}
+	}
+
+	function handleClickOutside(e: MouseEvent) {
+		e.preventDefault();
+		$state.visible = false;
+	}
+
+	@render {
+		<div
+			{$props?.id}
+			class={`torp-context ${$props?.class ?? ""}`.trim()}
+		>
+			<slot />
+		</div>
+	}
+}

package/dist/{Popover/PopoverContentContextual.torp → Contextual/ContextualContent.torp}

@@ -2,9 +2,9 @@
 import { addDocumentEvent, removeDocumentEvent } from "../utils/documentEvents";
 import getScrollParent from "../utils/getScrollParent";
 import setContextPosition from "../utils/setContextPosition";
-import { PopoverContextName, type PopoverContext } from "./PopoverTypes";
+import { ContextualContextName, type ContextualContext } from "./ContextualTypes";
 
-interface PopoverContentContextualProps {
+interface ContextualContentProps {
 	/** An ID for the root element */
 	id?: string;
 	/** Class name(s) for the root element */
@@ -12,20 +12,18 @@ interface PopoverContentContextualProps {
 }
 
 /**
- * The content that is displayed for a Popover when it is open, displayed at the
+ * The content that is displayed for a Contextual when it is open, displayed at the
  * position that the user right-clicked.
  */
-export default function PopoverContentContextual($props: PopoverContentContextualProps) {	
-	$props ??= $watch({});
-
+export default function ContextualContent($props: ContextualContentProps | undefined) {	
 	let div: HTMLDivElement;
 	let shown = false;
 	let closeOnClick = false;
 
-	// Get stuff out of the PopoverContext
-	const context = $context[PopoverContextName] as PopoverContext;
+	// Get stuff out of the ContextualContext
+	const context = $context[ContextualContextName] as ContextualContext;
 	if (!context) {
-		throw new Error("PopoverContentContextual must be contained within a Popover");
+		throw new Error("ContextualContent must be contained within a Contextual");
 	}
 	let $state = context.state;
 
@@ -46,7 +44,8 @@ export default function PopoverContentContextual($props: PopoverContentContextua
 
 		// Set the position and listen for window resize and scroll to reset the position
 		setPosition();
-		const scrollParent = getScrollParent(context.anchorElement)
+		const anchorElement = context.anchorElement!;
+		const scrollParent = getScrollParent(anchorElement)
 		scrollParent.addEventListener("resize", setPosition);
 		scrollParent.addEventListener("scroll", setPosition);
 		if (context.focusFirstElement) {
@@ -61,11 +60,12 @@ export default function PopoverContentContextual($props: PopoverContentContextua
 		removeDocumentEvent("click", handleDocumentClick);
 
 		// Stop listening for window resize and focus the anchor element per WAI guidelines
-		const scrollParent = getScrollParent(context.anchorElement)
+		const anchorElement = context.anchorElement!;
+		const scrollParent = getScrollParent(anchorElement)
 		scrollParent.removeEventListener("resize", setPosition);
 		scrollParent.removeEventListener("scroll", setPosition);
-		if (context.anchorElement?.focus) {
-			context.anchorElement.focus();
+		if (anchorElement.focus) {
+			anchorElement.focus();
 		}
 	}
 
@@ -97,8 +97,8 @@ export default function PopoverContentContextual($props: PopoverContentContextua
 	@render {
 		@if ($state.visible) {
 			<div
-				{$props.id}
-				class={`torp-popover-content-contextual ${$props.class ?? ""}`.trim()}
+				{$props?.id}
+				class={`torp-popover-content-contextual ${$props?.class ?? ""}`.trim()}
 				&ref={div}
 				onmount={show}
 			>

package/dist/Contextual/ContextualTrigger.torp

@@ -0,0 +1,66 @@
+import { ContextualContextName, type ContextualContext } from "./ContextualTypes";
+import hoverTrigger from "../mount/hoverTrigger";
+
+interface ContextualTriggerProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Class name(s) for the root element */
+	class?: string,
+	/** Whether the popover is activated by click/press or by hover **/
+	activation?: "press" | "hover"
+}
+
+/**
+ * The element that causes a Contextual to appear or disappear when right-clicked.
+ */
+export default function ContextualTrigger($props: ContextualTriggerProps | undefined) {
+	let activation = $props?.activation ?? "press";
+
+	// Get stuff out of the ContextualContext
+	const context = $context[ContextualContextName] as ContextualContext;
+	if (!context) {
+		throw new Error("ContextualTrigger must be contained within a Contextual");
+	}
+	let $state = context.state;
+
+	function handleContextualMenu(e: MouseEvent & { currentTarget: EventTarget & HTMLDivElement }) {
+		if (activation !== "press") return;
+
+		e.preventDefault();
+		if ($state.position) {
+			// Get the position relative to the element, so we can reposition on scroll
+			const rect = e.currentTarget.getBoundingClientRect();
+			const x = e.clientX - rect.left;
+			const y = e.clientY - rect.top;
+			$state.position = { x, y };
+			//$state.position = { x: window.scrollX + e.clientX, y: window.scrollY + e.clientY };
+		}
+		$state.visible = !$state.visible;
+	}
+
+	function handleHover(node: HTMLElement, e: MouseEvent) {
+		if (activation !== "hover") return;
+
+		if ($state.position) {
+			// Get the position relative to the element, so we can reposition on scroll
+			const rect = node.getBoundingClientRect();
+			const x = e.clientX - rect.left;
+			const y = e.clientY - rect.top;
+			$state.position = { x, y };
+			//$state.position = { x: window.scrollX + e.clientX, y: window.scrollY + e.clientY };
+		}
+		$state.visible = !$state.visible
+	}
+
+	@render {
+		<div
+			{$props?.id}
+			class={`torp-popover-trigger-contextual ${$props?.class ?? ""}`.trim()}
+			oncontextmenu={handleContextualMenu}
+			onmount={(el) => hoverTrigger(el, { onHover: handleHover, onExit: handleHover })}
+			&ref={context.anchorElement}
+		>
+			<slot />
+		</div>
+	}
+}

package/dist/Contextual/ContextualTypes.ts

@@ -0,0 +1,30 @@
+export const ContextualContextName = "Contextual";
+
+/** The shared context for popover components (Contextual, Prompt and Contextual) */
+export interface ContextualContext {
+	handleButton: (type: "confirm" | "cancel" | undefined, value?: any) => void;
+	// HACK: We need to be able to let children (i.e. Dialogs) override the click outside functionality
+	// There may be a more elegant way to accomplish this too
+	handleClickOutside?: (e: MouseEvent) => void;
+	state: ContextualState;
+	//modal: boolean;
+	anchorElement?: HTMLElement;
+	// HACK: focusFirstElement is necessary because if we focus the first element e.g. in a Dialog's
+	// onMount, it will scroll the page to the focused element and mess up our careful positioning
+	// We need to be able to manually set the order to
+	// 1. set visible (so we have an element with content)
+	// 2. set position (so the element is in the right place)
+	// 3. set focus (for accessibility)
+	// There may be a more elegant way to accomplish this!
+	focusFirstElement?: () => void;
+}
+
+export interface ContextualState {
+	visible: boolean;
+	position: Point;
+}
+
+export interface Point {
+	x: number;
+	y: number;
+}

package/dist/Contextual/index.d.ts

@@ -0,0 +1,90 @@
+import { type SlotRender } from "@torpor/view";
+
+
+interface ContextualProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Class name(s) for the root element */
+	class?: string,
+	/** Whether the contextual is modal. If true, an overlay should be supplied to obscure outside content, and only the context content will be visible to screen readers  */
+	modal?: boolean,
+	/** Whether the contextual is visible  */
+	visible?: boolean,
+	/** The element to anchor this contextual to, as an alternative to supplying a ContextualTrigger  */
+	anchor?: HTMLElement,
+	/** The position to display this contextual at  */
+	position?: Point,
+	/** A function to be called when the user selects a response */
+	callback?: ((value: any) => void),
+	/** Raised when this contextual is opened or closed */
+	ontoggle?: (open: boolean) => void,
+	/** Raised when the contextual has opened */
+	onopen?: () => void,
+	/** Raised when the contextual has closed */
+	onclose?: (result: any) => void,
+}
+
+/**
+ * A contextual window that is shown to the user at the cursor's location.
+ *
+ * The structure of a Contextual is:
+ *
+ * ```
+ * <Contextual>
+ * 	<ContextualTrigger /> (optional)
+ * 	<ContextualContent />
+ * </Contextual>
+ * ```
+ */
+declare function Contextual(
+	$parent: ParentNode,
+	$anchor: Node | null,
+	$props: ContextualProps | undefined,
+	$context?: Record<PropertyKey, any>,
+	$slots?: Record<string, SlotRender>,
+): void;
+
+
+
+interface ContextualContentProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Class name(s) for the root element */
+	class?: string,
+}
+
+/**
+ * The content that is displayed for a Contextual when it is open, displayed at the
+ * position that the user right-clicked.
+ */
+declare function ContextualContent(
+	$parent: ParentNode,
+	$anchor: Node | null,
+	$props: ContextualContentProps | undefined,
+	$context?: Record<PropertyKey, any>,
+	$slots?: Record<string, SlotRender>,
+): void;
+
+
+
+interface ContextualTriggerProps {
+	/** An ID for the root element */
+	id?: string;
+	/** Class name(s) for the root element */
+	class?: string,
+	/** Whether the popover is activated by click/press or by hover **/
+	activation?: "press" | "hover"
+}
+
+/**
+ * The element that causes a Contextual to appear or disappear when right-clicked.
+ */
+declare function ContextualTrigger(
+	$parent: ParentNode,
+	$anchor: Node | null,
+	$props: ContextualTriggerProps | undefined,
+	$context?: Record<PropertyKey, any>,
+	$slots?: Record<string, SlotRender>,
+): void;
+
+export { Contextual, ContextualContent, ContextualTrigger };

package/dist/Contextual/index.js

@@ -0,0 +1,14 @@
+// src/Contextual/Contextual.torp
+import Contextual_default from "./Contextual.torp";
+
+// src/Contextual/ContextualContent.torp
+import ContextualContent_default from "./ContextualContent.torp";
+
+// src/Contextual/ContextualTrigger.torp
+import ContextualTrigger_default from "./ContextualTrigger.torp";
+export {
+  Contextual_default as Contextual,
+  ContextualContent_default as ContextualContent,
+  ContextualTrigger_default as ContextualTrigger
+};
+//# sourceMappingURL=index.js.map

package/dist/Contextual/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/Dialog/Dialog.torp

@@ -1,8 +1,8 @@
 import getId from "../utils/getId";
-import { addDocumentEvent, removeDocumentEvent } from "../utils/documentEvents";
 import { trapFocus, type TrapFocusOptions } from "../mount/trapFocus";
-import { PopoverContextName, type PopoverContext } from "../Popover/PopoverTypes";
-import { DialogContextName, type DialogContext, type DialogState } from "./DialogTypes";
+import { ModalContextName, type ModalContext } from "../Modal/ModalTypes";
+import { PopoverContextName } from "../Popover/PopoverTypes";
+import { DialogContextName, type DialogContext, type DialogState, type HandleButtonPress } from "./DialogTypes";
 
 interface DialogProps {
 	/** An ID for the root element */
@@ -16,7 +16,9 @@ interface DialogProps {
 }
 
 /**
- * Content for a window displayed in a Popover.
+ * A dialog that can be used to show a message to the user, or get information from the user.
+ * 
+ * Dialogs are typically shown within a Modal or Popover.
  * 
  * See [the WAI ARIA guidelines for Dialogs](https://www.w3.org/WAI/ARIA/apg/patterns/dialogmodal/).
  * 
@@ -24,42 +26,44 @@ interface DialogProps {
  * 
  * ```
  * <Dialog>
- *     <DialogHeader /> (optional)
- *     <DialogBody /> (optional)
- *     <DialogFooter> (optional)
- *         <DialogButton /> (optional)
- *     </DialogFooter>
+ * 	<ModalOverlay /> (optional -- will set `modal` to true)
+ * 	<DialogHeader /> (optional)
+ * 	<DialogBody /> (optional)
+ * 	<DialogFooter> (optional)
+ * 		<DialogButton /> (optional)
+ * 	</DialogFooter>
  * </Dialog>
  * ```
  * 
  */
-export default function Dialog($props: DialogProps) {
-	$props ??= $watch({});
-	$props.id ??= getId();
-	$props.dialog ??= false;
+export default function Dialog($props: DialogProps | undefined) {
+	let defaultId = getId();
 
-	let div: HTMLDivElement;
+	//let div: HTMLDivElement;
 
 	let trapFocusOptions: TrapFocusOptions = {
 		focusableElements: []
 	};
 
-	// Get stuff out of the PopoverContext
-	const popoverContext = $context[PopoverContextName] as PopoverContext;
-	if (!popoverContext) {
-		throw new Error("Dialog must be contained within a Popover");
+	// Maybe get stuff out of a Modal context
+	let modal = false;
+	let visible = true;
+	let handleButton: HandleButtonPress | undefined = undefined;
+	const modalContext = $context[ModalContextName] ?? $context[PopoverContextName] as ModalContext;
+	if (modalContext) {
+		modal = true;
+		visible = modalContext.state.visible;
+		handleButton = modalContext.handleButton;
+
+		modalContext.handleClickOutside = handleClickOutside;
+		// Set the focusFirstElement method in the ModalContext so that it can be
+		// called after everything has been shown
+		modalContext.focusFirstElement = focusFirstElement;
 	}
-	const { handleButton, modal } = popoverContext;
-	const visible = popoverContext.state.visible;
-
-	popoverContext.handleClickOutside = handleClickOutside;
-	// Set the focusFirstElement method in the PopoverContext so that it can be
-	// called after everything has been shown
-	popoverContext.focusFirstElement = focusFirstElement;
 
 	// Set the IDs for using in the Dialog's ARIA attributes
 	let $state: DialogState = $watch({
-		dialogId: $props.id,
+		dialogId: $props?.id ?? defaultId,
 		headerId: "",
 		bodyId: "",
 		visible
@@ -69,60 +73,22 @@ export default function Dialog($props: DialogProps) {
 	let context: DialogContext = {
 		handleButton,
 		state: $state,
-		anchorElement: popoverContext.anchorElement
+		anchorElement: modalContext ? modalContext.anchorElement : undefined
 	};
 	$context[DialogContextName] = context;
 
-	let closeOnClick = false;
-
-	$mount(() => {
-		if ($state.visible) {
-			// HACK: Because this Dialog could be shown with a click, we need to
-			// wait for another mousedown before we close on click. Otherwise
-			// the click immediately bubbles to the document. I guess we could
-			// require the user to preventDefault after calling showPrompt etc,
-			// but that seems very error-prone?
-			closeOnClick = false;
-			addDocumentEvent("mousedown", handleDocumentMouseDown);
-			addDocumentEvent("click", handleDocumentClick);
-		} else {
-			removeDocumentEvent("mousedown", handleDocumentMouseDown);
-			removeDocumentEvent("click", handleDocumentClick);
-			// Focus the anchor element per WAI guidelines
-			if (context.anchorElement?.focus) {
-				context.anchorElement.focus();
-			}
-		}
-	});
-
 	function focusFirstElement() {
 		if (trapFocusOptions.focusableElements.length) {
 			trapFocusOptions.focusableElements[0].focus();
 		}
 	}
 
-	function handleDocumentMouseDown() {
-		closeOnClick = true;
-	}
-
-	function handleDocumentClick(e: MouseEvent) {
-		if (
-			closeOnClick &&
-			div &&
-			!div.contains(e.target as HTMLElement) &&
-			(!context.anchorElement || !context.anchorElement.contains(e.target as HTMLElement))
-		) {
-			handleClickOutside(e);
-		}
-	}
-
 	function handleClickOutside(e: MouseEvent) {
 		// Don't allow the user to click outside -- they must press a button or
 		// the Esc key
 		e.preventDefault();
 		if (!modal) {
-			popoverContext.state.visible = false;
-			context.state.visible = false;
+			modalContext.state.visible = false;
 		}
 	}
 
@@ -148,17 +114,17 @@ export default function Dialog($props: DialogProps) {
 
 	@render {
 		<div
-			{$props.id}
-			class={`torp-dialog ${$props.class ?? ""}`.trim()}
+			id={$props?.id ?? defaultId}
+			class={`torp-dialog ${$props?.class ?? ""}`.trim()}
 			tabindex="0"
-			role={$props.alert ? "alertdialog" : "dialog"}
+			role={$props?.alert === true ? "alertdialog" : "dialog"}
 			aria-modal={modal}
-			aria-label={$props.ariaLabel}
-			aria-labelledby={!$props.ariaLabel && $state.headerId ? $state.headerId : undefined}
+			aria-label={$props?.ariaLabel}
+			aria-labelledby={!$props?.ariaLabel && $state.headerId ? $state.headerId : undefined}
 			aria-describedby={$state.bodyId ? $state.bodyId : undefined}
 			onkeydown={handleKey}
 			onmount={(el) => trapFocus(el, trapFocusOptions)}
-			&ref={div}
+			@//&ref={div}
 		>
 			<slot />
 		</div>

package/dist/Dialog/DialogBody.torp

@@ -14,10 +14,8 @@ interface DialogBodyProps {
  * The body information for a Dialog. Content in the body will be announced by
  * screen readers when the Dialog is opened, unless ariaAnnounce is false.
  */
-export default function DialogBody($props: DialogBodyProps) {
-	$props ??= $watch({});
-	$props.id ??= getId();
-	$props.ariaAnnounce ??= true;
+export default function DialogBody($props: DialogBodyProps | undefined) {
+	let defaultId = getId();
 
 	// Get stuff out of the DialogContext
 	const context = $context[DialogContextName] as DialogContext;
@@ -27,14 +25,14 @@ export default function DialogBody($props: DialogBodyProps) {
 	let $state = context.state;
 
 	// Set the body id for using in the Dialog's ARIA attributes
-	if ($props.ariaAnnounce) {
-		$state.bodyId = $props.id;
+	if ($props?.ariaAnnounce !== false) {
+		$state.bodyId = $props?.id || defaultId;
 	}
 
 	@render {
 		<div
-			{$props.id} 
-			class={`torp-dialog-body ${$props.class ?? ""}`.trim()}
+			id={$props?.id ?? defaultId} 
+			class={`torp-dialog-body ${$props?.class ?? ""}`.trim()}
 		>
 			<slot />
 		</div>

package/dist/Dialog/DialogButton.torp

@@ -11,15 +11,15 @@ interface DialogButtonProps {
 	type?: "confirm" | "cancel",
 	/** Whether this button is disabled */
 	disabled?: boolean,
+	/** Raised when the button is clicked */
+	onclick?: (e: MouseEvent) => void,
 }
 
 /**
  * A button that is placed in a DialogFooter and signals a response by a user.
  * 
  */
-export default function DialogButton($props: DialogButtonProps) {
-	$props ??= $watch({});
-
+export default function DialogButton($props: DialogButtonProps | undefined) {
 	let button: HTMLButtonElement;
 
 	// Get stuff out of the DialogContext
@@ -31,26 +31,28 @@ export default function DialogButton($props: DialogButtonProps) {
 
 	$mount(() => {
 		// Store the confirm or cancel button in the DialogContext
-		if ($props.type === "confirm") {
+		if ($props?.type === "confirm") {
 			context.confirmButton = button;
-		} else if ($props.type === "cancel") {
+		} else if ($props?.type === "cancel") {
 			context.cancelButton = button;
 		}
 	});
 
-	function handleClick(e) {
-		if ($props.onclick) {
-			$props.onclick(e)
+	function handleClick(e: MouseEvent) {
+		if ($props?.onclick) {
+			$props?.onclick(e)
+		}
+		if (handleButton) {
+			handleButton($props?.type, $props?.value);
 		}
-		handleButton($props.type, $props.value);
 	}
 
 	@render {
 		<button
 			type="button"
-			{$props.id}
-			class={`torp-dialog-button ${$props.class ?? ""}`.trim()}
-			disabled={$props.disabled}
+			{$props?.id}
+			class={`torp-dialog-button ${$props?.class ?? ""}`.trim()}
+			disabled={$props?.disabled}
 			onclick={handleClick}
 			&ref={button}
 		>