350 lines
11 KiB
JavaScript
350 lines
11 KiB
JavaScript
/*
|
|
* Copyright (C) 2020 Yomichan Authors
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* global
|
|
* TaskAccumulator
|
|
*/
|
|
|
|
class DOMDataBinder {
|
|
constructor({selector, ignoreSelectors=[], createElementMetadata, compareElementMetadata, getValues, setValues, onError=null}) {
|
|
this._selector = selector;
|
|
this._ignoreSelectors = ignoreSelectors;
|
|
this._createElementMetadata = createElementMetadata;
|
|
this._compareElementMetadata = compareElementMetadata;
|
|
this._getValues = getValues;
|
|
this._setValues = setValues;
|
|
this._onError = onError;
|
|
this._updateTasks = new TaskAccumulator(this._onBulkUpdate.bind(this));
|
|
this._assignTasks = new TaskAccumulator(this._onBulkAssign.bind(this));
|
|
this._mutationObserver = new MutationObserver(this._onMutation.bind(this));
|
|
this._observingElement = null;
|
|
this._elementMap = new Map(); // Map([element => observer]...)
|
|
this._elementAncestorMap = new Map(); // Map([element => Set([observer]...))
|
|
}
|
|
|
|
observe(element) {
|
|
if (this._isObserving) { return; }
|
|
|
|
this._observingElement = element;
|
|
this._mutationObserver.observe(element, {
|
|
attributes: true,
|
|
attributeOldValue: true,
|
|
childList: true,
|
|
subtree: true
|
|
});
|
|
this._onMutation([{
|
|
type: 'childList',
|
|
target: element.parentNode,
|
|
addedNodes: [element],
|
|
removedNodes: []
|
|
}]);
|
|
}
|
|
|
|
disconnect() {
|
|
if (!this._isObserving) { return; }
|
|
|
|
this._mutationObserver.disconnect();
|
|
this._observingElement = null;
|
|
|
|
for (const observer of this._elementMap.values()) {
|
|
this._removeObserver(observer);
|
|
}
|
|
}
|
|
|
|
async refresh() {
|
|
await this._updateTasks.enqueue(null, {all: true});
|
|
}
|
|
|
|
// Private
|
|
|
|
_onMutation(mutationList) {
|
|
for (const mutation of mutationList) {
|
|
switch (mutation.type) {
|
|
case 'childList':
|
|
this._onChildListMutation(mutation);
|
|
break;
|
|
case 'attributes':
|
|
this._onAttributeMutation(mutation);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
_onChildListMutation({addedNodes, removedNodes, target}) {
|
|
const selector = this._selector;
|
|
const ELEMENT_NODE = Node.ELEMENT_NODE;
|
|
|
|
for (const node of removedNodes) {
|
|
const observers = this._elementAncestorMap.get(node);
|
|
if (typeof observers === 'undefined') { continue; }
|
|
for (const observer of observers) {
|
|
this._removeObserver(observer);
|
|
}
|
|
}
|
|
|
|
for (const node of addedNodes) {
|
|
if (node.nodeType !== ELEMENT_NODE) { continue; }
|
|
if (node.matches(selector)) {
|
|
this._createObserver(node);
|
|
}
|
|
for (const childNode of node.querySelectorAll(selector)) {
|
|
this._createObserver(childNode);
|
|
}
|
|
}
|
|
|
|
if (addedNodes.length !== 0 || addedNodes.length !== 0) {
|
|
const observer = this._elementMap.get(target);
|
|
if (typeof observer !== 'undefined' && observer.hasValue) {
|
|
this._setElementValue(observer.element, observer.value);
|
|
}
|
|
}
|
|
}
|
|
|
|
_onAttributeMutation({target}) {
|
|
const selector = this._selector;
|
|
const observers = this._elementAncestorMap.get(target);
|
|
if (typeof observers !== 'undefined') {
|
|
for (const observer of observers) {
|
|
const element = observer.element;
|
|
if (
|
|
!element.matches(selector) ||
|
|
this._shouldIgnoreElement(element) ||
|
|
this._isObserverStale(observer)
|
|
) {
|
|
this._removeObserver(observer);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (target.matches(selector)) {
|
|
this._createObserver(target);
|
|
}
|
|
}
|
|
|
|
async _onBulkUpdate(tasks) {
|
|
let all = false;
|
|
const targets = [];
|
|
for (const [observer, task] of tasks) {
|
|
if (observer === null) {
|
|
if (task.data.all) {
|
|
all = true;
|
|
break;
|
|
}
|
|
} else {
|
|
targets.push([observer, task]);
|
|
}
|
|
}
|
|
if (all) {
|
|
targets.length = 0;
|
|
for (const observer of this._elementMap.values()) {
|
|
targets.push([observer, null]);
|
|
}
|
|
}
|
|
|
|
const args = targets.map(([observer]) => ({
|
|
element: observer.element,
|
|
metadata: observer.metadata
|
|
}));
|
|
const responses = await this._getValues(args);
|
|
this._applyValues(targets, responses, true);
|
|
}
|
|
|
|
async _onBulkAssign(tasks) {
|
|
const targets = tasks;
|
|
const args = targets.map(([observer, task]) => ({
|
|
element: observer.element,
|
|
metadata: observer.metadata,
|
|
value: task.data.value
|
|
}));
|
|
const responses = await this._setValues(args);
|
|
this._applyValues(targets, responses, false);
|
|
}
|
|
|
|
_onElementChange(observer) {
|
|
const value = this._getElementValue(observer.element);
|
|
observer.value = value;
|
|
observer.hasValue = true;
|
|
this._assignTasks.enqueue(observer, {value});
|
|
}
|
|
|
|
_applyValues(targets, response, ignoreStale) {
|
|
if (!Array.isArray(response)) { return; }
|
|
|
|
for (let i = 0, ii = targets.length; i < ii; ++i) {
|
|
const [observer, task] = targets[i];
|
|
const {error, result} = response[i];
|
|
const stale = (task !== null && task.stale);
|
|
|
|
if (error) {
|
|
if (typeof this._onError === 'function') {
|
|
this._onError(error, stale, observer.element, observer.metadata);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (stale && !ignoreStale) { continue; }
|
|
|
|
observer.value = result;
|
|
observer.hasValue = true;
|
|
this._setElementValue(observer.element, result);
|
|
}
|
|
}
|
|
|
|
_createObserver(element) {
|
|
if (this._elementMap.has(element) || this._shouldIgnoreElement(element)) { return; }
|
|
|
|
const metadata = this._createElementMetadata(element);
|
|
const nodeName = element.nodeName.toUpperCase();
|
|
const ancestors = this._getAncestors(element);
|
|
const observer = {
|
|
element,
|
|
ancestors,
|
|
type: (nodeName === 'INPUT' ? element.type : null),
|
|
value: null,
|
|
hasValue: false,
|
|
onChange: null,
|
|
metadata
|
|
};
|
|
observer.onChange = this._onElementChange.bind(this, observer);
|
|
this._elementMap.set(element, observer);
|
|
|
|
element.addEventListener('change', observer.onChange, false);
|
|
|
|
for (const ancestor of ancestors) {
|
|
let observers = this._elementAncestorMap.get(ancestor);
|
|
if (typeof observers === 'undefined') {
|
|
observers = new Set();
|
|
this._elementAncestorMap.set(ancestor, observers);
|
|
}
|
|
observers.add(observer);
|
|
}
|
|
|
|
this._updateTasks.enqueue(observer);
|
|
}
|
|
|
|
_removeObserver(observer) {
|
|
const {element, ancestors} = observer;
|
|
|
|
element.removeEventListener('change', observer.onChange, false);
|
|
observer.onChange = null;
|
|
|
|
this._elementMap.delete(element);
|
|
|
|
for (const ancestor of ancestors) {
|
|
const observers = this._elementAncestorMap.get(ancestor);
|
|
if (typeof observers === 'undefined') { continue; }
|
|
|
|
observers.delete(observer);
|
|
if (observers.size === 0) {
|
|
this._elementAncestorMap.delete(ancestor);
|
|
}
|
|
}
|
|
}
|
|
|
|
_isObserverStale(observer) {
|
|
const {element, type, metadata} = observer;
|
|
const nodeName = element.nodeName.toUpperCase();
|
|
return !(
|
|
type === (nodeName === 'INPUT' ? element.type : null) &&
|
|
this._compareElementMetadata(metadata, this._createElementMetadata(element))
|
|
);
|
|
}
|
|
|
|
_shouldIgnoreElement(element) {
|
|
for (const selector of this._ignoreSelectors) {
|
|
if (element.matches(selector)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
_getAncestors(node) {
|
|
const root = this._observingElement;
|
|
const results = [];
|
|
while (true) {
|
|
results.push(node);
|
|
if (node === root) { break; }
|
|
node = node.parentNode;
|
|
if (node === null) { break; }
|
|
}
|
|
return results;
|
|
}
|
|
|
|
_setElementValue(element, value) {
|
|
switch (element.nodeName.toUpperCase()) {
|
|
case 'INPUT':
|
|
switch (element.type) {
|
|
case 'checkbox':
|
|
element.checked = value;
|
|
break;
|
|
case 'text':
|
|
case 'number':
|
|
element.value = value;
|
|
break;
|
|
}
|
|
break;
|
|
case 'TEXTAREA':
|
|
case 'SELECT':
|
|
element.value = value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
_getElementValue(element) {
|
|
switch (element.nodeName.toUpperCase()) {
|
|
case 'INPUT':
|
|
switch (element.type) {
|
|
case 'checkbox':
|
|
return !!element.checked;
|
|
case 'text':
|
|
return `${element.value}`;
|
|
case 'number':
|
|
return this._getInputNumberValue(element);
|
|
}
|
|
break;
|
|
case 'TEXTAREA':
|
|
case 'SELECT':
|
|
return element.value;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
_getInputNumberValue(element) {
|
|
let value = parseFloat(element.value);
|
|
if (!Number.isFinite(value)) { return 0; }
|
|
|
|
let {min, max, step} = element;
|
|
min = this._stringValueToNumberOrNull(min);
|
|
max = this._stringValueToNumberOrNull(max);
|
|
step = this._stringValueToNumberOrNull(step);
|
|
if (typeof min === 'number') { value = Math.max(value, min); }
|
|
if (typeof max === 'number') { value = Math.min(value, max); }
|
|
if (typeof step === 'number' && step !== 0) { value = Math.round(value / step) * step; }
|
|
return value;
|
|
}
|
|
|
|
_stringValueToNumberOrNull(value) {
|
|
if (typeof value !== 'string' || value.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
const number = parseFloat(value);
|
|
return !Number.isNaN(number) ? number : null;
|
|
}
|
|
}
|