@aegisjsproject/callback-registry 1.0.1 → 1.0.3

package/callbacks.js

@@ -1,9 +1,17 @@
+import {
+	eventToProp, capture as captureAttr, once as onceAttr, passive as passiveAttr, signal as signalAttr,
+	registerEventAttribute, hasEventAttribute, registerSignal, abortController,
+} from './events.js';
+
 let _isRegistrationOpen = true;
 
 const $$ = (selector, base = document) => base.querySelectorAll(selector);
 
 const $ = (selector, base = document) => base.querySelector(selector);
 
+export const requestFullscreen = { attr: 'data-request-fullscreen-selector', data: 'requestFullscreenSelector' };
+export const toggleFullsceen = { attr: 'data-toggle-fullscreen-selector', data: 'toggleFullscreenSelector' };
+
 export const FUNCS = {
 	debug: {
 		log: 'aegis:debug:log',
@@ -15,10 +23,12 @@ export const FUNCS = {
 		back: 'aegis:navigate:back',
 		forward: 'aegis:navigate:forward',
 		reload: 'aegis:navigate:reload',
+		close: 'aegis:navigate:close',
 		link: 'aegis:navigate:go',
 		popup: 'aegis:navigate:popup',
 	},
 	ui: {
+		command: 'aegis:ui:command',
 		print: 'aegis:ui:print',
 		remove: 'aegis:ui:remove',
 		hide: 'aegis:ui:hide',
@@ -32,6 +42,14 @@ export const FUNCS = {
 		disable: 'aegis:ui:disable',
 		scrollTo: 'aegis:ui:scrollTo',
 		prevent: 'aegis:ui:prevent',
+		revokeObjectURL: 'aegis:ui:revokeObjectURL',
+		cancelAnimationFrame: 'aegis:ui:cancelAnimationFrame',
+		requestFullscreen: 'aegis:ui:requestFullscreen',
+		toggleFullscreen: 'aegis:ui:toggleFullsceen',
+		exitFullsceen: 'aegis:ui:exitFullscreen',
+		open: 'aegis:ui:open',
+		close: 'aegis:ui:close',
+		abortController: 'aegis:ui:controller:abort',
 	},
 };
 
@@ -43,6 +61,7 @@ const registry = new Map([
 	[FUNCS.navigate.back, () => history.back()],
 	[FUNCS.navigate.forward, () => history.forward()],
 	[FUNCS.navigate.reload, () => history.go(0)],
+	[FUNCS.navigate.close, () => globalThis.close()],
 	[FUNCS.navigate.link, event => {
 		if (event.isTrusted) {
 			event.preventDefault();
@@ -81,6 +100,13 @@ const registry = new Map([
 			});
 		}
 	}],
+	[FUNCS.ui.revokeObjectURL, ({ currentTarget }) => URL.revokeObjectURL(currentTarget.src)],
+	[FUNCS.ui.cancelAnimationFrame, ({ currentTarget }) => cancelAnimationFrame(parseInt(currentTarget.dataset.animationFrame))],
+	[FUNCS.ui.clearInterval, ({ currentTarget }) => clearInterval(parseInt(currentTarget.dataset.clearInterval))],
+	[FUNCS.ui.clearTimeout, ({ currentTarget }) => clearTimeout(parseInt(currentTarget.dataset.timeout))],
+	[FUNCS.ui.abortController, ({ currentTarget }) => abortController(currentTarget.dataset.aegisEventController, currentTarget.dataset.aegisControllerReason)],
+	[FUNCS.ui.open, ({ currentTarget }) => document.querySelector(currentTarget.dataset.openSelector).open = true],
+	[FUNCS.ui.close, ({ currentTarget }) => document.querySelector(currentTarget.dataset.closeSelector).open = false],
 	[FUNCS.ui.showModal, ({ currentTarget }) => {
 		const target = $(currentTarget.dataset.showModalSelector);
 
@@ -118,6 +144,25 @@ const registry = new Map([
 	}],
 	[FUNCS.ui.print, () => globalThis.print()],
 	[FUNCS.ui.prevent, event => event.preventDefault()],
+	[FUNCS.ui.requestFullscreen, ({ currentTarget}) => {
+		if (currentTarget.dataset.hasOwnProperty(requestFullscreen.data)) {
+			document.getElementById(currentTarget.dataset[requestFullscreen.data]).requestFullscreen();
+		} else {
+			currentTarget.requestFullscreen();
+		}
+	}],
+	[FUNCS.ui.toggleFullscreen, ({ currentTarget }) => {
+		const target = currentTarget.dataset.hasOwnProperty(toggleFullsceen.data)
+			? document.getElementById(currentTarget.dataset[toggleFullsceen.data])
+			: currentTarget;
+
+		if (target.isSameNode(document.fullscreenElement)) {
+			document.exitFullscreen();
+		} else {
+			target.requestFullscreen();
+		}
+	}],
+	[FUNCS.ui.exitFullsceen, () => document.exitFullscreen()],
 ]);
 
 /**
@@ -237,3 +282,39 @@ export function getHost(target) {
 		return null;
 	}
 }
+
+export function on(event, callback, { capture = false, passive = false, once = false, signal } = {}) {
+	if (callback instanceof Function) {
+		return on(event, createCallback(callback), { capture, passive, once, signal });
+	} else if (typeof callback !== 'string' || callback.length === 0) {
+		throw new TypeError('Callback must be a function or a registered callback string.');
+	} else if (typeof event !== 'string' || event.length === 0) {
+		throw new TypeError('Event must be a non-empty string.');
+	} else {
+		if (! hasEventAttribute(event)) {
+			registerEventAttribute(event);
+		}
+
+		const parts = [[eventToProp(event), callback]];
+
+		if (capture) {
+			parts.push([captureAttr, '']);
+		}
+
+		if (passive) {
+			parts.push([passiveAttr, '']);
+		}
+
+		if (once) {
+			parts.push([onceAttr, '']);
+		}
+
+		if (signal instanceof AbortSignal) {
+			parts.push([signalAttr, registerSignal(signal)]);
+		} else if (typeof signal === 'string') {
+			parts.push([signalAttr, signal]);
+		}
+
+		return parts.map(([prop, val]) => `${prop}="${val}"`).join(' ');
+	}
+}