1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
/*
* Copyright (C) 2021 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/>.
*/
class TemplateRendererMediaProvider {
constructor() {
this._requirements = null;
}
get requirements() {
return this._requirements;
}
set requirements(value) {
this._requirements = value;
}
hasMedia(root, args, namedArgs) {
const {media} = root;
const data = this._getMediaData(media, args, namedArgs);
return (data !== null);
}
getMedia(root, args, namedArgs) {
const {media} = root;
const data = this._getMediaData(media, args, namedArgs);
if (data !== null) {
const {format} = namedArgs;
const result = this._getFormattedValue(data, format);
if (typeof result === 'string') { return result; }
}
const defaultValue = namedArgs.default;
return typeof defaultValue !== 'undefined' ? defaultValue : '';
}
// Private
_addRequirement(value) {
if (this._requirements === null) { return; }
this._requirements.push(value);
}
_getFormattedValue(data, format) {
return Object.prototype.hasOwnProperty.call(data, format) ? data[format] : null;
}
_getMediaData(media, args, namedArgs) {
const type = args[0];
switch (type) {
case 'audio': return this._getSimpleMediaData(media, 'audio');
case 'screenshot': return this._getSimpleMediaData(media, 'screenshot');
case 'clipboardImage': return this._getSimpleMediaData(media, 'clipboardImage');
case 'clipboardText': return this._getSimpleMediaData(media, 'clipboardText');
case 'selectionText': return this._getSimpleMediaData(media, 'selectionText');
case 'textFurigana': return this._getTextFurigana(media, args[1], namedArgs);
case 'dictionaryMedia': return this._getDictionaryMedia(media, args[1], namedArgs);
default: return null;
}
}
_getSimpleMediaData(media, type) {
const result = media[type];
if (typeof result === 'object' && result !== null) { return result; }
this._addRequirement({type});
return null;
}
_getDictionaryMedia(media, path, namedArgs) {
const {dictionaryMedia} = media;
const {dictionary} = namedArgs;
if (
typeof dictionaryMedia !== 'undefined' &&
typeof dictionary === 'string' &&
Object.prototype.hasOwnProperty.call(dictionaryMedia, dictionary)
) {
const dictionaryMedia2 = dictionaryMedia[dictionary];
if (Object.prototype.hasOwnProperty.call(dictionaryMedia2, path)) {
const result = dictionaryMedia2[path];
if (typeof result === 'object' && result !== null) {
return result;
}
}
}
this._addRequirement({
type: 'dictionaryMedia',
dictionary,
path
});
return null;
}
_getTextFurigana(media, text, namedArgs) {
const {readingMode=null} = namedArgs;
const {textFurigana} = media;
if (Array.isArray(textFurigana)) {
for (const entry of textFurigana) {
if (entry.text !== text || entry.readingMode !== readingMode) { continue; }
return entry.details;
}
}
this._addRequirement({
type: 'textFurigana',
text,
readingMode
});
return null;
}
}
|