@schukai/monster 3.51.5 → 3.52.1

package/source/dom/resourcemanager.mjs

@@ -28,121 +28,121 @@ export { ResourceManager };
  * @summary A Resource class
  */
 class ResourceManager extends Base {
-    /**
-     *
-     * @param {Object} options
-     * throw {Error} unsupported document type
-     */
-    constructor(options) {
-        super(options);
-        equipWithInternal.call(this);
-
-        if (!(this.getOption("document") instanceof Document)) {
-            throw new Error("unsupported document type");
-        }
-    }
-
-    /**
-     * @deprecated since 3.15.0 use getInternal instead
-     * @property {string} baseurl
-     */
-    getOption(key) {
-        return this.getInternal(key);
-    }
-
-    /**
-     * @property {string} baseurl
-     */
-    getBaseURL() {
-        this.getOption("document")?.baseURL;
-    }
-
-    /**
-     * @property {string} baseurl
-     * @deprecated since 3.15.0 use internalDefaults instead
-     */
-    get defaults() {
-        return this.internalDefaults;
-    }
-
-    /**
-     *
-     * @property {HTMLDocument} document=document Document
-     * @property {Object} resources
-     * @property {Array} resources.scripts=[] array with {@link Monster.DOM.Resource.Script} objects
-     * @property {Array} resources.stylesheets=[] array with {@link Monster.DOM.Resource.Link.Stylesheet} objects
-     * @property {Array} resources.data=[] array with {@link Monster.DOM.Resource.Data} objects
-     */
-    get internalDefaults() {
-        return Object.assign(
-            {},
-            {
-                document: getGlobalObject("document"),
-                resources: {
-                    scripts: [],
-                    stylesheets: [],
-                    data: [],
-                },
-            },
-        );
-    }
-
-    /**
-     * Append Tags to DOM
-     *
-     * @return {Monster.DOM.ResourceManager}
-     * @throws {Error} unsupported resource definition
-     */
-    connect() {
-        runResourceMethod.call(this, "connect");
-        return this;
-    }
-
-    /**
-     * Check if available
-     *
-     * @return {Promise}
-     * @throws {Error} unsupported resource definition
-     */
-    available() {
-        return Promise.all(runResourceMethod.call(this, "available"));
-    }
-
-    /**
-     * Add a script
-     *
-     * @param {string|URL} url
-     * @param [Object|undefined} options
-     * @return {Monster.DOM.ResourceManager}
-     * @see Monster.DOM.Resource.Script
-     */
-    addScript(url, options) {
-        return addResource.call(this, "scripts", url, options);
-    }
-
-    /**
-     * Add Stylesheet
-     *
-     * @param {string|URL} url
-     * @param [Object|undefined} options
-     * @return {Monster.DOM.ResourceManager}
-     * @see Monster.DOM.Resource.Link.Stylesheet
-     */
-    addStylesheet(url, options) {
-        return addResource.call(this, "stylesheets", url, options);
-    }
-
-    /**
-     * Add Data Tag
-     *
-     * @param {string|URL} url
-     * @param [Object|undefined} options
-     * @return {Monster.DOM.ResourceManager}
-     * @see Monster.DOM.Resource.Data
-     */
-    addData(url, options) {
-        return addResource.call(this, "data", url, options);
-    }
+	/**
+	 *
+	 * @param {Object} options
+	 * throw {Error} unsupported document type
+	 */
+	constructor(options) {
+		super(options);
+		equipWithInternal.call(this);
+
+		if (!(this.getOption("document") instanceof Document)) {
+			throw new Error("unsupported document type");
+		}
+	}
+
+	/**
+	 * @deprecated since 3.15.0 use getInternal instead
+	 * @property {string} baseurl
+	 */
+	getOption(key) {
+		return this.getInternal(key);
+	}
+
+	/**
+	 * @property {string} baseurl
+	 */
+	getBaseURL() {
+		this.getOption("document")?.baseURL;
+	}
+
+	/**
+	 * @property {string} baseurl
+	 * @deprecated since 3.15.0 use internalDefaults instead
+	 */
+	get defaults() {
+		return this.internalDefaults;
+	}
+
+	/**
+	 *
+	 * @property {HTMLDocument} document=document Document
+	 * @property {Object} resources
+	 * @property {Array} resources.scripts=[] array with {@link Monster.DOM.Resource.Script} objects
+	 * @property {Array} resources.stylesheets=[] array with {@link Monster.DOM.Resource.Link.Stylesheet} objects
+	 * @property {Array} resources.data=[] array with {@link Monster.DOM.Resource.Data} objects
+	 */
+	get internalDefaults() {
+		return Object.assign(
+			{},
+			{
+				document: getGlobalObject("document"),
+				resources: {
+					scripts: [],
+					stylesheets: [],
+					data: [],
+				},
+			},
+		);
+	}
+
+	/**
+	 * Append Tags to DOM
+	 *
+	 * @return {Monster.DOM.ResourceManager}
+	 * @throws {Error} unsupported resource definition
+	 */
+	connect() {
+		runResourceMethod.call(this, "connect");
+		return this;
+	}
+
+	/**
+	 * Check if available
+	 *
+	 * @return {Promise}
+	 * @throws {Error} unsupported resource definition
+	 */
+	available() {
+		return Promise.all(runResourceMethod.call(this, "available"));
+	}
+
+	/**
+	 * Add a script
+	 *
+	 * @param {string|URL} url
+	 * @param [Object|undefined} options
+	 * @return {Monster.DOM.ResourceManager}
+	 * @see Monster.DOM.Resource.Script
+	 */
+	addScript(url, options) {
+		return addResource.call(this, "scripts", url, options);
+	}
+
+	/**
+	 * Add Stylesheet
+	 *
+	 * @param {string|URL} url
+	 * @param [Object|undefined} options
+	 * @return {Monster.DOM.ResourceManager}
+	 * @see Monster.DOM.Resource.Link.Stylesheet
+	 */
+	addStylesheet(url, options) {
+		return addResource.call(this, "stylesheets", url, options);
+	}
+
+	/**
+	 * Add Data Tag
+	 *
+	 * @param {string|URL} url
+	 * @param [Object|undefined} options
+	 * @return {Monster.DOM.ResourceManager}
+	 * @see Monster.DOM.Resource.Data
+	 */
+	addData(url, options) {
+		return addResource.call(this, "data", url, options);
+	}
 }
 
 /**
@@ -151,26 +151,24 @@ class ResourceManager extends Base {
  * @return {Array}
  */
 function runResourceMethod(method) {
-    const self = this;
+	const result = [];
 
-    const result = [];
+	for (const type of ["scripts", "stylesheets", "data"]) {
+		const resources = this.getOption(`resources.${type}`);
+		if (!isArray(resources)) {
+			continue;
+		}
 
-    for (const type of ["scripts", "stylesheets", "data"]) {
-        const resources = self.getOption(`resources.${type}`);
-        if (!isArray(resources)) {
-            continue;
-        }
+		for (const resource of resources) {
+			if (!(resource instanceof Resource)) {
+				throw new Error("unsupported resource definition");
+			}
 
-        for (const resource of resources) {
-            if (!(resource instanceof Resource)) {
-                throw new Error("unsupported resource definition");
-            }
+			result.push(resource[method]());
+		}
+	}
 
-            result.push(resource[method]());
-        }
-    }
-
-    return result;
+	return result;
 }
 
 /**
@@ -182,29 +180,27 @@ function runResourceMethod(method) {
  * @private
  */
 function addResource(type, url, options) {
-    const self = this;
-
-    if (url instanceof URL) {
-        url = url.toString();
-    }
-
-    options = options || {};
-
-    let resource;
-    switch (type) {
-        case "scripts":
-            resource = new Script(extend({}, options, { [ATTRIBUTE_SRC]: url }));
-            break;
-        case "stylesheets":
-            resource = new Stylesheet(extend({}, options, { [ATTRIBUTE_HREF]: url }));
-            break;
-        case "data":
-            resource = new Data(extend({}, options, { [ATTRIBUTE_SRC]: url }));
-            break;
-        default:
-            throw new Error(`unsupported type ${type}`);
-    }
-
-    self.getOption("resources")?.[type].push(resource);
-    return self;
+	if (url instanceof URL) {
+		url = url.toString();
+	}
+
+	options = options || {};
+
+	let resource;
+	switch (type) {
+		case "scripts":
+			resource = new Script(extend({}, options, { [ATTRIBUTE_SRC]: url }));
+			break;
+		case "stylesheets":
+			resource = new Stylesheet(extend({}, options, { [ATTRIBUTE_HREF]: url }));
+			break;
+		case "data":
+			resource = new Data(extend({}, options, { [ATTRIBUTE_SRC]: url }));
+			break;
+		default:
+			throw new Error(`unsupported type ${type}`);
+	}
+
+	this.getOption("resources")?.[type].push(resource);
+	return this;
 }

package/source/dom/slotted.mjs

@@ -14,47 +14,46 @@ export { getSlottedElements, getSlottedNodes };
  * @throws {Error} query must be a string
  */
 function getSlottedNodes(query, name) {
-    const self = this;
-    const result = new Set();
-
-    if (!self.shadowRoot) {
-        return result;
-    }
-
-    let selector = "slot";
-    if (name !== undefined) {
-        if (name === null) {
-            selector += ":not([name])";
-        } else {
-            selector += `[name=${validateString(name)}]`;
-        }
-    }
-
-    const slots = self.shadowRoot.querySelectorAll(selector);
-
-    for (const [, slot] of Object.entries(slots)) {
-        slot.assignedNodes().forEach(function (node) {
-            if (node === null || node === undefined) {
-                return;
-            }
-
-            if (isString(query)) {
-                node.querySelectorAll(query).forEach(function (n) {
-                    result.add(n);
-                });
-
-                if (node.matches(query)) {
-                    result.add(node);
-                }
-            } else if (query !== undefined) {
-                throw new Error("query must be a string");
-            } else {
-                result.add(node);
-            }
-        });
-    }
-
-    return result;
+	const result = new Set();
+
+	if (!this.shadowRoot) {
+		return result;
+	}
+
+	let selector = "slot";
+	if (name !== undefined) {
+		if (name === null) {
+			selector += ":not([name])";
+		} else {
+			selector += `[name=${validateString(name)}]`;
+		}
+	}
+
+	const slots = this.shadowRoot.querySelectorAll(selector);
+
+	for (const [, slot] of Object.entries(slots)) {
+		slot.assignedNodes().forEach(function (node) {
+			if (node === null || node === undefined) {
+				return;
+			}
+
+			if (isString(query)) {
+				node.querySelectorAll(query).forEach(function (n) {
+					result.add(n);
+				});
+
+				if (node.matches(query)) {
+					result.add(node);
+				}
+			} else if (query !== undefined) {
+				throw new Error("query must be a string");
+			} else {
+				result.add(node);
+			}
+		});
+	}
+
+	return result;
 }
 
 /**
@@ -68,43 +67,42 @@ function getSlottedNodes(query, name) {
  * @throws {Error} query must be a string
  */
 function getSlottedElements(query, name) {
-    const self = this;
-    const result = new Set();
-
-    if (!(self.shadowRoot instanceof ShadowRoot)) {
-        return result;
-    }
-
-    let selector = "slot";
-    if (name !== undefined) {
-        if (name === null) {
-            selector += ":not([name])";
-        } else {
-            selector += `[name=${validateString(name)}]`;
-        }
-    }
-
-    const slots = self.shadowRoot.querySelectorAll(selector);
-
-    for (const [, slot] of Object.entries(slots)) {
-        slot.assignedElements().forEach(function (node) {
-            if (!(node instanceof HTMLElement)) return;
-
-            if (isString(query)) {
-                node.querySelectorAll(query).forEach(function (n) {
-                    result.add(n);
-                });
-
-                if (node.matches(query)) {
-                    result.add(node);
-                }
-            } else if (query !== undefined) {
-                throw new Error("query must be a string");
-            } else {
-                result.add(node);
-            }
-        });
-    }
-
-    return result;
+	const result = new Set();
+
+	if (!(this.shadowRoot instanceof ShadowRoot)) {
+		return result;
+	}
+
+	let selector = "slot";
+	if (name !== undefined) {
+		if (name === null) {
+			selector += ":not([name])";
+		} else {
+			selector += `[name=${validateString(name)}]`;
+		}
+	}
+
+	const slots = this.shadowRoot.querySelectorAll(selector);
+
+	for (const [, slot] of Object.entries(slots)) {
+		slot.assignedElements().forEach(function (node) {
+			if (!(node instanceof HTMLElement)) return;
+
+			if (isString(query)) {
+				node.querySelectorAll(query).forEach(function (n) {
+					result.add(n);
+				});
+
+				if (node.matches(query)) {
+					result.add(node);
+				}
+			} else if (query !== undefined) {
+				throw new Error("query must be a string");
+			} else {
+				result.add(node);
+			}
+		});
+	}
+
+	return result;
 }