blob: c5c27a2bd4a7c70deb3a31fac6fe6402fed34809 (
plain)
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/**
@license
Copyright (c) 2017 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
*/
'use strict';
import templateMap from './template-map.js';
import {StyleNode} from './css-parse.js'; // eslint-disable-line no-unused-vars
/*
* Utilities for handling invalidating apply-shim mixins for a given template.
*
* The invalidation strategy involves keeping track of the "current" version of a template's mixins, and updating that count when a mixin is invalidated.
* The template
*/
/** @const {string} */
const CURRENT_VERSION = '_applyShimCurrentVersion';
/** @const {string} */
const NEXT_VERSION = '_applyShimNextVersion';
/** @const {string} */
const VALIDATING_VERSION = '_applyShimValidatingVersion';
/**
* @const {Promise<void>}
*/
const promise = Promise.resolve();
/**
* @param {string} elementName
*/
export function invalidate(elementName){
let template = templateMap[elementName];
if (template) {
invalidateTemplate(template);
}
}
/**
* This function can be called multiple times to mark a template invalid
* and signal that the style inside must be regenerated.
*
* Use `startValidatingTemplate` to begin an asynchronous validation cycle.
* During that cycle, call `templateIsValidating` to see if the template must
* be revalidated
* @param {HTMLTemplateElement} template
*/
export function invalidateTemplate(template) {
// default the current version to 0
template[CURRENT_VERSION] = template[CURRENT_VERSION] || 0;
// ensure the "validating for" flag exists
template[VALIDATING_VERSION] = template[VALIDATING_VERSION] || 0;
// increment the next version
template[NEXT_VERSION] = (template[NEXT_VERSION] || 0) + 1;
}
/**
* @param {string} elementName
* @return {boolean}
*/
export function isValid(elementName) {
let template = templateMap[elementName];
if (template) {
return templateIsValid(template);
}
return true;
}
/**
* @param {HTMLTemplateElement} template
* @return {boolean}
*/
export function templateIsValid(template) {
return template[CURRENT_VERSION] === template[NEXT_VERSION];
}
/**
* @param {string} elementName
* @return {boolean}
*/
export function isValidating(elementName) {
let template = templateMap[elementName];
if (template) {
return templateIsValidating(template);
}
return false;
}
/**
* Returns true if the template is currently invalid and `startValidating` has been called since the last invalidation.
* If false, the template must be validated.
* @param {HTMLTemplateElement} template
* @return {boolean}
*/
export function templateIsValidating(template) {
return !templateIsValid(template) && template[VALIDATING_VERSION] === template[NEXT_VERSION];
}
/**
* the template is marked as `validating` for one microtask so that all instances
* found in the tree crawl of `applyStyle` will update themselves,
* but the template will only be updated once.
* @param {string} elementName
*/
export function startValidating(elementName) {
let template = templateMap[elementName];
startValidatingTemplate(template);
}
/**
* Begin an asynchronous invalidation cycle.
* This should be called after every validation of a template
*
* After one microtask, the template will be marked as valid until the next call to `invalidateTemplate`
* @param {HTMLTemplateElement} template
*/
export function startValidatingTemplate(template) {
// remember that the current "next version" is the reason for this validation cycle
template[VALIDATING_VERSION] = template[NEXT_VERSION];
// however, there only needs to be one async task to clear the counters
if (!template._validating) {
template._validating = true;
promise.then(function() {
// sync the current version to let future invalidations cause a refresh cycle
template[CURRENT_VERSION] = template[NEXT_VERSION];
template._validating = false;
});
}
}
/**
* @return {boolean}
*/
export function elementsAreInvalid() {
for (let elementName in templateMap) {
let template = templateMap[elementName];
if (!templateIsValid(template)) {
return true;
}
}
return false;
}
|
