From 89517ae7a767d326155adc92c5912dc8f5f7bfbf Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Tue, 10 Oct 2017 12:03:00 -0700 Subject: [PATCH 1/8] fixed miscounting --- Recipe.min.js | 28 +++++++++++++++++----------- cssUsage.src.js | 28 +++++++++++++++++----------- src/cssUsage.js | 28 +++++++++++++++++----------- tests/test-page-atrules/styles.css | 3 +++ 4 files changed, 54 insertions(+), 33 deletions(-) diff --git a/Recipe.min.js b/Recipe.min.js index e96e982..9cc9f48 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -828,7 +828,7 @@ void function() { try { "conditions": {}} } else { var count = atrulesUsage[selectorText].count; - count = count++; + atrulesUsage[selectorText].count = count + 1; } var selectedAtruleUsage = atrulesUsage[selectorText]; @@ -879,15 +879,20 @@ void function() { try { } if(nestRuleSelector) { - if(!nestedRulesUsage[nestRuleSelector]) { - nestedRulesUsage[nestRuleSelector] = Object.create(null); - nestedRulesUsage[nestRuleSelector] = {"count": 1} - } else { - var nestedCount = nestedRulesUsage[nestRuleSelector].count; - nestedCount = nestedCount++; + var individualNested = nestRuleSelector.split(' '); + + for (let selector of individualNested) { + if(!nestedRulesUsage[selector]) { + nestedRulesUsage[selector] = Object.create(null); + nestedRulesUsage[selector] = {"count": 1} + } else { + var nestedCount = nestedRulesUsage[selector].count; + nestedRulesUsage[selector].count = nestedCount + 1; + } } } } + } /** @@ -901,7 +906,7 @@ void function() { try { selectedAtruleConditionalUsage[conditionText] = {"count": 1} } else { var count = selectedAtruleConditionalUsage[conditionText].count; - count = count++; + selectedAtruleConditionalUsage[conditionText].count = count + 1; } } @@ -920,7 +925,7 @@ void function() { try { "props": {}} } else { var count = atrulesUsage[selectorText].count; - count = count++; + atrulesUsage[selectorText].count = count + 1; } // @keyframes rule type is 7 @@ -957,7 +962,7 @@ void function() { try { pseudosUsageForSelector[pseudoClass] = {"count": 1}; } else { var pseudoCount = pseudosUsageForSelector[pseudoClass].count; - pseudoCount = pseudoCount++; + pseudosUsageForSelector[pseudoClass].count = pseudoCount + 1; } } @@ -990,7 +995,7 @@ void function() { try { atrulesUsageForKeyframeOfSelector[keyframe.keyText] = {"count": 1}; } else { var keyframeCount = atrulesUsageForKeyframeOfSelector[keyframe.keyText].count; - keyframeCount = keyframeCount++; + atrulesUsageForKeyframeOfSelector[keyframe.keyText].count = keyframeCount + 1; } } } @@ -1813,6 +1818,7 @@ void function() { try { CSSUsageResults.usages = results; deleteDuplicatedAtRules(); // TODO: issue #52 + console.log(CSSUsageResults); if(window.debugCSSUsage) if(window.debugCSSUsage) console.log(CSSUsageResults.usages); } diff --git a/cssUsage.src.js b/cssUsage.src.js index 3746fe2..90c58f2 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -828,7 +828,7 @@ void function() { try { "conditions": {}} } else { var count = atrulesUsage[selectorText].count; - count = count++; + atrulesUsage[selectorText].count = count + 1; } var selectedAtruleUsage = atrulesUsage[selectorText]; @@ -879,15 +879,20 @@ void function() { try { } if(nestRuleSelector) { - if(!nestedRulesUsage[nestRuleSelector]) { - nestedRulesUsage[nestRuleSelector] = Object.create(null); - nestedRulesUsage[nestRuleSelector] = {"count": 1} - } else { - var nestedCount = nestedRulesUsage[nestRuleSelector].count; - nestedCount = nestedCount++; + var individualNested = nestRuleSelector.split(' '); + + for (let selector of individualNested) { + if(!nestedRulesUsage[selector]) { + nestedRulesUsage[selector] = Object.create(null); + nestedRulesUsage[selector] = {"count": 1} + } else { + var nestedCount = nestedRulesUsage[selector].count; + nestedRulesUsage[selector].count = nestedCount + 1; + } } } } + } /** @@ -901,7 +906,7 @@ void function() { try { selectedAtruleConditionalUsage[conditionText] = {"count": 1} } else { var count = selectedAtruleConditionalUsage[conditionText].count; - count = count++; + selectedAtruleConditionalUsage[conditionText].count = count + 1; } } @@ -920,7 +925,7 @@ void function() { try { "props": {}} } else { var count = atrulesUsage[selectorText].count; - count = count++; + atrulesUsage[selectorText].count = count + 1; } // @keyframes rule type is 7 @@ -957,7 +962,7 @@ void function() { try { pseudosUsageForSelector[pseudoClass] = {"count": 1}; } else { var pseudoCount = pseudosUsageForSelector[pseudoClass].count; - pseudoCount = pseudoCount++; + pseudosUsageForSelector[pseudoClass].count = pseudoCount + 1; } } @@ -990,7 +995,7 @@ void function() { try { atrulesUsageForKeyframeOfSelector[keyframe.keyText] = {"count": 1}; } else { var keyframeCount = atrulesUsageForKeyframeOfSelector[keyframe.keyText].count; - keyframeCount = keyframeCount++; + atrulesUsageForKeyframeOfSelector[keyframe.keyText].count = keyframeCount + 1; } } } @@ -1813,6 +1818,7 @@ void function() { try { CSSUsageResults.usages = results; deleteDuplicatedAtRules(); // TODO: issue #52 + console.log(CSSUsageResults); if(window.debugCSSUsage) if(window.debugCSSUsage) console.log(CSSUsageResults.usages); } diff --git a/src/cssUsage.js b/src/cssUsage.js index 82926f6..8d226b8 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -331,7 +331,7 @@ void function() { try { "conditions": {}} } else { var count = atrulesUsage[selectorText].count; - count = count++; + atrulesUsage[selectorText].count = count + 1; } var selectedAtruleUsage = atrulesUsage[selectorText]; @@ -382,15 +382,20 @@ void function() { try { } if(nestRuleSelector) { - if(!nestedRulesUsage[nestRuleSelector]) { - nestedRulesUsage[nestRuleSelector] = Object.create(null); - nestedRulesUsage[nestRuleSelector] = {"count": 1} - } else { - var nestedCount = nestedRulesUsage[nestRuleSelector].count; - nestedCount = nestedCount++; + var individualNested = nestRuleSelector.split(' '); + + for (let selector of individualNested) { + if(!nestedRulesUsage[selector]) { + nestedRulesUsage[selector] = Object.create(null); + nestedRulesUsage[selector] = {"count": 1} + } else { + var nestedCount = nestedRulesUsage[selector].count; + nestedRulesUsage[selector].count = nestedCount + 1; + } } } } + } /** @@ -404,7 +409,7 @@ void function() { try { selectedAtruleConditionalUsage[conditionText] = {"count": 1} } else { var count = selectedAtruleConditionalUsage[conditionText].count; - count = count++; + selectedAtruleConditionalUsage[conditionText].count = count + 1; } } @@ -423,7 +428,7 @@ void function() { try { "props": {}} } else { var count = atrulesUsage[selectorText].count; - count = count++; + atrulesUsage[selectorText].count = count + 1; } // @keyframes rule type is 7 @@ -460,7 +465,7 @@ void function() { try { pseudosUsageForSelector[pseudoClass] = {"count": 1}; } else { var pseudoCount = pseudosUsageForSelector[pseudoClass].count; - pseudoCount = pseudoCount++; + pseudosUsageForSelector[pseudoClass].count = pseudoCount + 1; } } @@ -493,7 +498,7 @@ void function() { try { atrulesUsageForKeyframeOfSelector[keyframe.keyText] = {"count": 1}; } else { var keyframeCount = atrulesUsageForKeyframeOfSelector[keyframe.keyText].count; - keyframeCount = keyframeCount++; + atrulesUsageForKeyframeOfSelector[keyframe.keyText].count = keyframeCount + 1; } } } @@ -1316,6 +1321,7 @@ void function() { try { CSSUsageResults.usages = results; deleteDuplicatedAtRules(); // TODO: issue #52 + console.log(CSSUsageResults); if(window.debugCSSUsage) if(window.debugCSSUsage) console.log(CSSUsageResults.usages); } diff --git a/tests/test-page-atrules/styles.css b/tests/test-page-atrules/styles.css index 268bd10..372df4e 100644 --- a/tests/test-page-atrules/styles.css +++ b/tests/test-page-atrules/styles.css @@ -77,6 +77,9 @@ h2 { } @media screen and (min-width:480px) { + p { + background-color: whitesmoke; + } body{ background-color:#6aa6cc; From 8d17d7df343012fa48f2534eda3ef51cd5932b04 Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Tue, 10 Oct 2017 12:05:31 -0700 Subject: [PATCH 2/8] removed exact numbers of conditions --- Recipe.min.js | 1 + cssUsage.src.js | 1 + src/cssUsage.js | 1 + 3 files changed, 3 insertions(+) diff --git a/Recipe.min.js b/Recipe.min.js index 9cc9f48..714eb88 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -901,6 +901,7 @@ void function() { try { * of the @atrule in question. */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { + conditionText = conditionText.replace(/[0-9]/g, ''); if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} diff --git a/cssUsage.src.js b/cssUsage.src.js index 90c58f2..ce26bee 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -901,6 +901,7 @@ void function() { try { * of the @atrule in question. */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { + conditionText = conditionText.replace(/[0-9]/g, ''); if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} diff --git a/src/cssUsage.js b/src/cssUsage.js index 8d226b8..2a064b8 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -404,6 +404,7 @@ void function() { try { * of the @atrule in question. */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { + conditionText = conditionText.replace(/[0-9]/g, ''); if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} From 5ff70e2c535b2130c54d9ab401b4d14c8dd27722 Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Fri, 13 Oct 2017 15:43:00 -0700 Subject: [PATCH 3/8] removed nested rules usage data --- Recipe.min.js | 58 +------------------------------------------------ cssUsage.src.js | 58 +------------------------------------------------ src/cssUsage.js | 58 +------------------------------------------------ 3 files changed, 3 insertions(+), 171 deletions(-) diff --git a/Recipe.min.js b/Recipe.min.js index 714eb88..ebeb2b6 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -824,7 +824,6 @@ void function() { try { atrulesUsage[selectorText] = Object.create(null); atrulesUsage[selectorText] = {"count": 1, "props": {}, - "nested": {}, "conditions": {}} } else { var count = atrulesUsage[selectorText].count; @@ -835,66 +834,11 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); - processNestedRules(rule, selectedAtruleUsage.nested); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); } - /** - * Analyzes the given @atrules, such as @supports, and counts the usage of the nested rules - * according to their type. NOTE: must pass in the current usage of nested rules for the - * given @atrule. - */ - function processNestedRules(rule, nestedRulesUsage) { - // find the rule count for nested rules - for(let index in rule.cssRules) { - let ruleBody = rule.cssRules[index]; - - if(!ruleBody.cssText) { - continue; - } - - var nestRuleSelector; - - if(isRuleAnAtRule(ruleBody)) { - nestRuleSelector = '@atrule:' + ruleBody.type; - - } else if(ruleBody.style) { - if(ruleBody.selectorText) { - try { - var selectorText = CSSUsage.PropertyValuesAnalyzer.cleanSelectorText(ruleBody.selectorText); - var matchedElements = [].slice.call(document.querySelectorAll(selectorText)); - - if(matchedElements.length == 0) { - continue; - } - - var cleanedSelector = CSSUsage.PropertyValuesAnalyzer.generalizedSelectorsOf(selectorText); - nestRuleSelector = cleanedSelector[0]; // only passed in one selector to a function that returns many - } catch (ex) { - continue; - } - } - } - - if(nestRuleSelector) { - var individualNested = nestRuleSelector.split(' '); - - for (let selector of individualNested) { - if(!nestedRulesUsage[selector]) { - nestedRulesUsage[selector] = Object.create(null); - nestedRulesUsage[selector] = {"count": 1} - } else { - var nestedCount = nestedRulesUsage[selector].count; - nestedRulesUsage[selector].count = nestedCount + 1; - } - } - } - } - - } - /** * This processes the usage of conditions of conditional @atrules like @media. * Requires the condition of the rule to process and the current recorded usage @@ -1538,7 +1482,7 @@ void function() { try { propsForSelectedAtrule[normalizedKey] = {"count": 1}; } else { var propCount = propsForSelectedAtrule[normalizedKey].count; - propCount = propCount++; + propsForSelectedAtrule[normalizedKey].count = propCount + 1; } } } diff --git a/cssUsage.src.js b/cssUsage.src.js index ce26bee..e9785be 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -824,7 +824,6 @@ void function() { try { atrulesUsage[selectorText] = Object.create(null); atrulesUsage[selectorText] = {"count": 1, "props": {}, - "nested": {}, "conditions": {}} } else { var count = atrulesUsage[selectorText].count; @@ -835,66 +834,11 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); - processNestedRules(rule, selectedAtruleUsage.nested); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); } - /** - * Analyzes the given @atrules, such as @supports, and counts the usage of the nested rules - * according to their type. NOTE: must pass in the current usage of nested rules for the - * given @atrule. - */ - function processNestedRules(rule, nestedRulesUsage) { - // find the rule count for nested rules - for(let index in rule.cssRules) { - let ruleBody = rule.cssRules[index]; - - if(!ruleBody.cssText) { - continue; - } - - var nestRuleSelector; - - if(isRuleAnAtRule(ruleBody)) { - nestRuleSelector = '@atrule:' + ruleBody.type; - - } else if(ruleBody.style) { - if(ruleBody.selectorText) { - try { - var selectorText = CSSUsage.PropertyValuesAnalyzer.cleanSelectorText(ruleBody.selectorText); - var matchedElements = [].slice.call(document.querySelectorAll(selectorText)); - - if(matchedElements.length == 0) { - continue; - } - - var cleanedSelector = CSSUsage.PropertyValuesAnalyzer.generalizedSelectorsOf(selectorText); - nestRuleSelector = cleanedSelector[0]; // only passed in one selector to a function that returns many - } catch (ex) { - continue; - } - } - } - - if(nestRuleSelector) { - var individualNested = nestRuleSelector.split(' '); - - for (let selector of individualNested) { - if(!nestedRulesUsage[selector]) { - nestedRulesUsage[selector] = Object.create(null); - nestedRulesUsage[selector] = {"count": 1} - } else { - var nestedCount = nestedRulesUsage[selector].count; - nestedRulesUsage[selector].count = nestedCount + 1; - } - } - } - } - - } - /** * This processes the usage of conditions of conditional @atrules like @media. * Requires the condition of the rule to process and the current recorded usage @@ -1538,7 +1482,7 @@ void function() { try { propsForSelectedAtrule[normalizedKey] = {"count": 1}; } else { var propCount = propsForSelectedAtrule[normalizedKey].count; - propCount = propCount++; + propsForSelectedAtrule[normalizedKey].count = propCount + 1; } } } diff --git a/src/cssUsage.js b/src/cssUsage.js index 2a064b8..00d3a46 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -327,7 +327,6 @@ void function() { try { atrulesUsage[selectorText] = Object.create(null); atrulesUsage[selectorText] = {"count": 1, "props": {}, - "nested": {}, "conditions": {}} } else { var count = atrulesUsage[selectorText].count; @@ -338,66 +337,11 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); - processNestedRules(rule, selectedAtruleUsage.nested); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); } - /** - * Analyzes the given @atrules, such as @supports, and counts the usage of the nested rules - * according to their type. NOTE: must pass in the current usage of nested rules for the - * given @atrule. - */ - function processNestedRules(rule, nestedRulesUsage) { - // find the rule count for nested rules - for(let index in rule.cssRules) { - let ruleBody = rule.cssRules[index]; - - if(!ruleBody.cssText) { - continue; - } - - var nestRuleSelector; - - if(isRuleAnAtRule(ruleBody)) { - nestRuleSelector = '@atrule:' + ruleBody.type; - - } else if(ruleBody.style) { - if(ruleBody.selectorText) { - try { - var selectorText = CSSUsage.PropertyValuesAnalyzer.cleanSelectorText(ruleBody.selectorText); - var matchedElements = [].slice.call(document.querySelectorAll(selectorText)); - - if(matchedElements.length == 0) { - continue; - } - - var cleanedSelector = CSSUsage.PropertyValuesAnalyzer.generalizedSelectorsOf(selectorText); - nestRuleSelector = cleanedSelector[0]; // only passed in one selector to a function that returns many - } catch (ex) { - continue; - } - } - } - - if(nestRuleSelector) { - var individualNested = nestRuleSelector.split(' '); - - for (let selector of individualNested) { - if(!nestedRulesUsage[selector]) { - nestedRulesUsage[selector] = Object.create(null); - nestedRulesUsage[selector] = {"count": 1} - } else { - var nestedCount = nestedRulesUsage[selector].count; - nestedRulesUsage[selector].count = nestedCount + 1; - } - } - } - } - - } - /** * This processes the usage of conditions of conditional @atrules like @media. * Requires the condition of the rule to process and the current recorded usage @@ -1041,7 +985,7 @@ void function() { try { propsForSelectedAtrule[normalizedKey] = {"count": 1}; } else { var propCount = propsForSelectedAtrule[normalizedKey].count; - propCount = propCount++; + propsForSelectedAtrule[normalizedKey].count = propCount + 1; } } } From 3c3f31b7f226004491072a0b98b0fa80df754795 Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Mon, 16 Oct 2017 12:56:27 -0700 Subject: [PATCH 4/8] removed excess keyframes that are chained and @atrule:8 data --- Recipe.min.js | 32 +++++++++++++++++++++++++++----- cssUsage.src.js | 32 +++++++++++++++++++++++++++----- src/cssUsage.js | 32 +++++++++++++++++++++++++++----- 3 files changed, 81 insertions(+), 15 deletions(-) diff --git a/Recipe.min.js b/Recipe.min.js index ebeb2b6..df71e0d 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -935,12 +935,18 @@ void function() { try { let keyframe = rule.cssRules[index]; var atrulesUsageForKeyframeOfSelector = atrulesUsageForSelector.keyframes; - if(keyframe.keyText) { - if(!atrulesUsageForKeyframeOfSelector[keyframe.keyText]) { - atrulesUsageForKeyframeOfSelector[keyframe.keyText] = {"count": 1}; + if(!keyframe.keyText) { + continue; + } + + var frames = keyframe.keyText.split(', '); + + for (let frame of frames) { + if(!atrulesUsageForKeyframeOfSelector[frame]) { + atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; } else { - var keyframeCount = atrulesUsageForKeyframeOfSelector[keyframe.keyText].count; - atrulesUsageForKeyframeOfSelector[keyframe.keyText].count = keyframeCount + 1; + var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; + atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; } } } @@ -1455,6 +1461,20 @@ void function() { try { continue; } + if(ruleBody.selector) { + try { + var selectorText = CssPropertyValuesAnalyzer.cleanSelectorText(ruleBody.selectorText); + var matchedElements = [].slice.call(document.querySelectorAll(selectorText)); + + if (matchedElements.length == 0) { + continue; + } + } catch (ex) { + console.warn(ex.stack||("Invalid selector: "+selectorText+" -- via "+ruleBody.selectorText)); + continue; + } + } + let cssText = ' ' + style.cssText.toLowerCase(); for (var i = style.length; i--;) { @@ -1781,6 +1801,8 @@ void function() { try { delete cssUsageRules[key]; } } + + delete CSSUsageResults.atrules["@atrule:8"]; // delete duplicated data from atrule:7, keyframe } }(); diff --git a/cssUsage.src.js b/cssUsage.src.js index e9785be..5bb3724 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -935,12 +935,18 @@ void function() { try { let keyframe = rule.cssRules[index]; var atrulesUsageForKeyframeOfSelector = atrulesUsageForSelector.keyframes; - if(keyframe.keyText) { - if(!atrulesUsageForKeyframeOfSelector[keyframe.keyText]) { - atrulesUsageForKeyframeOfSelector[keyframe.keyText] = {"count": 1}; + if(!keyframe.keyText) { + continue; + } + + var frames = keyframe.keyText.split(', '); + + for (let frame of frames) { + if(!atrulesUsageForKeyframeOfSelector[frame]) { + atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; } else { - var keyframeCount = atrulesUsageForKeyframeOfSelector[keyframe.keyText].count; - atrulesUsageForKeyframeOfSelector[keyframe.keyText].count = keyframeCount + 1; + var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; + atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; } } } @@ -1455,6 +1461,20 @@ void function() { try { continue; } + if(ruleBody.selector) { + try { + var selectorText = CssPropertyValuesAnalyzer.cleanSelectorText(ruleBody.selectorText); + var matchedElements = [].slice.call(document.querySelectorAll(selectorText)); + + if (matchedElements.length == 0) { + continue; + } + } catch (ex) { + console.warn(ex.stack||("Invalid selector: "+selectorText+" -- via "+ruleBody.selectorText)); + continue; + } + } + let cssText = ' ' + style.cssText.toLowerCase(); for (var i = style.length; i--;) { @@ -1781,6 +1801,8 @@ void function() { try { delete cssUsageRules[key]; } } + + delete CSSUsageResults.atrules["@atrule:8"]; // delete duplicated data from atrule:7, keyframe } }(); diff --git a/src/cssUsage.js b/src/cssUsage.js index 00d3a46..ac58314 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -438,12 +438,18 @@ void function() { try { let keyframe = rule.cssRules[index]; var atrulesUsageForKeyframeOfSelector = atrulesUsageForSelector.keyframes; - if(keyframe.keyText) { - if(!atrulesUsageForKeyframeOfSelector[keyframe.keyText]) { - atrulesUsageForKeyframeOfSelector[keyframe.keyText] = {"count": 1}; + if(!keyframe.keyText) { + continue; + } + + var frames = keyframe.keyText.split(', '); + + for (let frame of frames) { + if(!atrulesUsageForKeyframeOfSelector[frame]) { + atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; } else { - var keyframeCount = atrulesUsageForKeyframeOfSelector[keyframe.keyText].count; - atrulesUsageForKeyframeOfSelector[keyframe.keyText].count = keyframeCount + 1; + var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; + atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; } } } @@ -958,6 +964,20 @@ void function() { try { continue; } + if(ruleBody.selector) { + try { + var selectorText = CssPropertyValuesAnalyzer.cleanSelectorText(ruleBody.selectorText); + var matchedElements = [].slice.call(document.querySelectorAll(selectorText)); + + if (matchedElements.length == 0) { + continue; + } + } catch (ex) { + console.warn(ex.stack||("Invalid selector: "+selectorText+" -- via "+ruleBody.selectorText)); + continue; + } + } + let cssText = ' ' + style.cssText.toLowerCase(); for (var i = style.length; i--;) { @@ -1284,6 +1304,8 @@ void function() { try { delete cssUsageRules[key]; } } + + delete CSSUsageResults.atrules["@atrule:8"]; // delete duplicated data from atrule:7, keyframe } }(); From b793408a48a3d3b3bb549092b24cd37a9b2a7c1c Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Mon, 16 Oct 2017 15:50:30 -0700 Subject: [PATCH 5/8] basic processing of only nested at rules added --- Recipe.min.js | 69 +++++++++++++++++++++++++++---------------------- cssUsage.src.js | 69 +++++++++++++++++++++++++++---------------------- src/cssUsage.js | 69 +++++++++++++++++++++++++++---------------------- 3 files changed, 114 insertions(+), 93 deletions(-) diff --git a/Recipe.min.js b/Recipe.min.js index df71e0d..90611aa 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -834,6 +834,7 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); + processNestedAtRules(rule.cssRules, selectedAtruleUsage); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); @@ -846,6 +847,8 @@ void function() { try { */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { conditionText = conditionText.replace(/[0-9]/g, ''); + conditionText = conditionText.replace(".px", "px"); + conditionText = conditionText.replace(".em", "px"); if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -855,6 +858,41 @@ void function() { try { } } + /** + * This processes the usage of nested atrules within other at rules. + */ + function processNestedAtRules(cssRules, selectedAtruleConditionalUsage) { + for(let index in cssRules) { + let ruleBody = cssRules[index]; + + + if(!ruleBody.cssText) { + continue; + } + + // only collect stats for sub atrules + if(!isRuleAnAtRule(ruleBody)) { + continue; + } + + var nestRuleSelector = nestRuleSelector = '@atrule:' + ruleBody.type; + + if(!selectedAtruleConditionalUsage["nested"]) { + selectedAtruleConditionalUsage["nested"] = Object.create(null); + } + + var nestedUsage = selectedAtruleConditionalUsage["nested"]; + + if(!nestedUsage[nestRuleSelector]) { + nestedUsage[nestRuleSelector] = Object.create(null); + nestedUsage[nestRuleSelector] = { "count": 1 } + } else { + var nestedCount = nestedUsage[nestRuleSelector].count; + nestedUsage[nestRuleSelector].count = nestedCount + 1; + } + } + } + /** * This will process all other @atrules that don't have conditions or styles. * [1] It will process any props and values used within the body of the rule. @@ -879,39 +917,8 @@ void function() { try { } else if(CSSUsageResults.rules[selectorText].props) { atrulesUsage[selectorText].props = CSSUsageResults.rules[selectorText].props; } - - if(rule.pseudoClass) { - processPseudoClassesOfAtrules(rule); - } } - - /** - * If an atrule as has a pseudo class such as @page, process the pseudo class and - * add it to the atrule usage. - */ - function processPseudoClassesOfAtrules(rule) { - var selectorText = '@atrule:' + rule.type; - var selectorAtruleUsage = CSSUsageResults.atrules[selectorText]; - - if(!selectorAtruleUsage["pseudos"]) { - selectorAtruleUsage["pseudos"] = Object.create(null); - selectorAtruleUsage["pseudos"] = {}; - } - - var pseudosUsageForSelector = selectorAtruleUsage["pseudos"]; - let pseudoClass = rule.pseudoClass; - - if(!pseudosUsageForSelector[pseudoClass]) { - pseudosUsageForSelector[pseudoClass] = Object.create(null); - pseudosUsageForSelector[pseudoClass] = {"count": 1}; - } else { - var pseudoCount = pseudosUsageForSelector[pseudoClass].count; - pseudosUsageForSelector[pseudoClass].count = pseudoCount + 1; - } - } - - /** * Processes on @keyframe to add the appropriate props from the frame and a counter of which * frames are used throughout the document. diff --git a/cssUsage.src.js b/cssUsage.src.js index 5bb3724..0b81d79 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -834,6 +834,7 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); + processNestedAtRules(rule.cssRules, selectedAtruleUsage); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); @@ -846,6 +847,8 @@ void function() { try { */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { conditionText = conditionText.replace(/[0-9]/g, ''); + conditionText = conditionText.replace(".px", "px"); + conditionText = conditionText.replace(".em", "px"); if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -855,6 +858,41 @@ void function() { try { } } + /** + * This processes the usage of nested atrules within other at rules. + */ + function processNestedAtRules(cssRules, selectedAtruleConditionalUsage) { + for(let index in cssRules) { + let ruleBody = cssRules[index]; + + + if(!ruleBody.cssText) { + continue; + } + + // only collect stats for sub atrules + if(!isRuleAnAtRule(ruleBody)) { + continue; + } + + var nestRuleSelector = nestRuleSelector = '@atrule:' + ruleBody.type; + + if(!selectedAtruleConditionalUsage["nested"]) { + selectedAtruleConditionalUsage["nested"] = Object.create(null); + } + + var nestedUsage = selectedAtruleConditionalUsage["nested"]; + + if(!nestedUsage[nestRuleSelector]) { + nestedUsage[nestRuleSelector] = Object.create(null); + nestedUsage[nestRuleSelector] = { "count": 1 } + } else { + var nestedCount = nestedUsage[nestRuleSelector].count; + nestedUsage[nestRuleSelector].count = nestedCount + 1; + } + } + } + /** * This will process all other @atrules that don't have conditions or styles. * [1] It will process any props and values used within the body of the rule. @@ -879,39 +917,8 @@ void function() { try { } else if(CSSUsageResults.rules[selectorText].props) { atrulesUsage[selectorText].props = CSSUsageResults.rules[selectorText].props; } - - if(rule.pseudoClass) { - processPseudoClassesOfAtrules(rule); - } } - - /** - * If an atrule as has a pseudo class such as @page, process the pseudo class and - * add it to the atrule usage. - */ - function processPseudoClassesOfAtrules(rule) { - var selectorText = '@atrule:' + rule.type; - var selectorAtruleUsage = CSSUsageResults.atrules[selectorText]; - - if(!selectorAtruleUsage["pseudos"]) { - selectorAtruleUsage["pseudos"] = Object.create(null); - selectorAtruleUsage["pseudos"] = {}; - } - - var pseudosUsageForSelector = selectorAtruleUsage["pseudos"]; - let pseudoClass = rule.pseudoClass; - - if(!pseudosUsageForSelector[pseudoClass]) { - pseudosUsageForSelector[pseudoClass] = Object.create(null); - pseudosUsageForSelector[pseudoClass] = {"count": 1}; - } else { - var pseudoCount = pseudosUsageForSelector[pseudoClass].count; - pseudosUsageForSelector[pseudoClass].count = pseudoCount + 1; - } - } - - /** * Processes on @keyframe to add the appropriate props from the frame and a counter of which * frames are used throughout the document. diff --git a/src/cssUsage.js b/src/cssUsage.js index ac58314..135246f 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -337,6 +337,7 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); + processNestedAtRules(rule.cssRules, selectedAtruleUsage); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); @@ -349,6 +350,8 @@ void function() { try { */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { conditionText = conditionText.replace(/[0-9]/g, ''); + conditionText = conditionText.replace(".px", "px"); + conditionText = conditionText.replace(".em", "px"); if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -358,6 +361,41 @@ void function() { try { } } + /** + * This processes the usage of nested atrules within other at rules. + */ + function processNestedAtRules(cssRules, selectedAtruleConditionalUsage) { + for(let index in cssRules) { + let ruleBody = cssRules[index]; + + + if(!ruleBody.cssText) { + continue; + } + + // only collect stats for sub atrules + if(!isRuleAnAtRule(ruleBody)) { + continue; + } + + var nestRuleSelector = nestRuleSelector = '@atrule:' + ruleBody.type; + + if(!selectedAtruleConditionalUsage["nested"]) { + selectedAtruleConditionalUsage["nested"] = Object.create(null); + } + + var nestedUsage = selectedAtruleConditionalUsage["nested"]; + + if(!nestedUsage[nestRuleSelector]) { + nestedUsage[nestRuleSelector] = Object.create(null); + nestedUsage[nestRuleSelector] = { "count": 1 } + } else { + var nestedCount = nestedUsage[nestRuleSelector].count; + nestedUsage[nestRuleSelector].count = nestedCount + 1; + } + } + } + /** * This will process all other @atrules that don't have conditions or styles. * [1] It will process any props and values used within the body of the rule. @@ -382,39 +420,8 @@ void function() { try { } else if(CSSUsageResults.rules[selectorText].props) { atrulesUsage[selectorText].props = CSSUsageResults.rules[selectorText].props; } - - if(rule.pseudoClass) { - processPseudoClassesOfAtrules(rule); - } } - - /** - * If an atrule as has a pseudo class such as @page, process the pseudo class and - * add it to the atrule usage. - */ - function processPseudoClassesOfAtrules(rule) { - var selectorText = '@atrule:' + rule.type; - var selectorAtruleUsage = CSSUsageResults.atrules[selectorText]; - - if(!selectorAtruleUsage["pseudos"]) { - selectorAtruleUsage["pseudos"] = Object.create(null); - selectorAtruleUsage["pseudos"] = {}; - } - - var pseudosUsageForSelector = selectorAtruleUsage["pseudos"]; - let pseudoClass = rule.pseudoClass; - - if(!pseudosUsageForSelector[pseudoClass]) { - pseudosUsageForSelector[pseudoClass] = Object.create(null); - pseudosUsageForSelector[pseudoClass] = {"count": 1}; - } else { - var pseudoCount = pseudosUsageForSelector[pseudoClass].count; - pseudosUsageForSelector[pseudoClass].count = pseudoCount + 1; - } - } - - /** * Processes on @keyframe to add the appropriate props from the frame and a counter of which * frames are used throughout the document. From 170ca18ec17008bf28611b29e3b3807315b5b0a2 Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Tue, 17 Oct 2017 12:15:28 -0700 Subject: [PATCH 6/8] final clean up --- Recipe.min.js | 44 +++++--------------------------------------- cssUsage.src.js | 44 +++++--------------------------------------- src/cssUsage.js | 44 +++++--------------------------------------- 3 files changed, 15 insertions(+), 117 deletions(-) diff --git a/Recipe.min.js b/Recipe.min.js index 90611aa..c0690c8 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -834,7 +834,6 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); - processNestedAtRules(rule.cssRules, selectedAtruleUsage); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); @@ -846,9 +845,9 @@ void function() { try { * of the @atrule in question. */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { - conditionText = conditionText.replace(/[0-9]/g, ''); - conditionText = conditionText.replace(".px", "px"); - conditionText = conditionText.replace(".em", "px"); + // replace numeric specific information from condition statements + conditionText = conditionText.replace(/[0-9]+.*[0-9]+/g, ''); + if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -858,41 +857,6 @@ void function() { try { } } - /** - * This processes the usage of nested atrules within other at rules. - */ - function processNestedAtRules(cssRules, selectedAtruleConditionalUsage) { - for(let index in cssRules) { - let ruleBody = cssRules[index]; - - - if(!ruleBody.cssText) { - continue; - } - - // only collect stats for sub atrules - if(!isRuleAnAtRule(ruleBody)) { - continue; - } - - var nestRuleSelector = nestRuleSelector = '@atrule:' + ruleBody.type; - - if(!selectedAtruleConditionalUsage["nested"]) { - selectedAtruleConditionalUsage["nested"] = Object.create(null); - } - - var nestedUsage = selectedAtruleConditionalUsage["nested"]; - - if(!nestedUsage[nestRuleSelector]) { - nestedUsage[nestRuleSelector] = Object.create(null); - nestedUsage[nestRuleSelector] = { "count": 1 } - } else { - var nestedCount = nestedUsage[nestRuleSelector].count; - nestedUsage[nestRuleSelector].count = nestedCount + 1; - } - } - } - /** * This will process all other @atrules that don't have conditions or styles. * [1] It will process any props and values used within the body of the rule. @@ -916,6 +880,7 @@ void function() { try { processKeyframeAtRules(rule); } else if(CSSUsageResults.rules[selectorText].props) { atrulesUsage[selectorText].props = CSSUsageResults.rules[selectorText].props; + delete atrulesUsage[selectorText].props.values; } } @@ -937,6 +902,7 @@ void function() { try { * WARN: tightly coupled with previous processing of rules. */ atrulesUsageForSelector.props = CSSUsageResults.rules["@atrule:8"].props; + delete atrulesUsageForSelector.props.values; for(let index in rule.cssRules) { let keyframe = rule.cssRules[index]; diff --git a/cssUsage.src.js b/cssUsage.src.js index 0b81d79..f867fee 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -834,7 +834,6 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); - processNestedAtRules(rule.cssRules, selectedAtruleUsage); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); @@ -846,9 +845,9 @@ void function() { try { * of the @atrule in question. */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { - conditionText = conditionText.replace(/[0-9]/g, ''); - conditionText = conditionText.replace(".px", "px"); - conditionText = conditionText.replace(".em", "px"); + // replace numeric specific information from condition statements + conditionText = conditionText.replace(/[0-9]+.*[0-9]+/g, ''); + if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -858,41 +857,6 @@ void function() { try { } } - /** - * This processes the usage of nested atrules within other at rules. - */ - function processNestedAtRules(cssRules, selectedAtruleConditionalUsage) { - for(let index in cssRules) { - let ruleBody = cssRules[index]; - - - if(!ruleBody.cssText) { - continue; - } - - // only collect stats for sub atrules - if(!isRuleAnAtRule(ruleBody)) { - continue; - } - - var nestRuleSelector = nestRuleSelector = '@atrule:' + ruleBody.type; - - if(!selectedAtruleConditionalUsage["nested"]) { - selectedAtruleConditionalUsage["nested"] = Object.create(null); - } - - var nestedUsage = selectedAtruleConditionalUsage["nested"]; - - if(!nestedUsage[nestRuleSelector]) { - nestedUsage[nestRuleSelector] = Object.create(null); - nestedUsage[nestRuleSelector] = { "count": 1 } - } else { - var nestedCount = nestedUsage[nestRuleSelector].count; - nestedUsage[nestRuleSelector].count = nestedCount + 1; - } - } - } - /** * This will process all other @atrules that don't have conditions or styles. * [1] It will process any props and values used within the body of the rule. @@ -916,6 +880,7 @@ void function() { try { processKeyframeAtRules(rule); } else if(CSSUsageResults.rules[selectorText].props) { atrulesUsage[selectorText].props = CSSUsageResults.rules[selectorText].props; + delete atrulesUsage[selectorText].props.values; } } @@ -937,6 +902,7 @@ void function() { try { * WARN: tightly coupled with previous processing of rules. */ atrulesUsageForSelector.props = CSSUsageResults.rules["@atrule:8"].props; + delete atrulesUsageForSelector.props.values; for(let index in rule.cssRules) { let keyframe = rule.cssRules[index]; diff --git a/src/cssUsage.js b/src/cssUsage.js index 135246f..0737dc4 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -337,7 +337,6 @@ void function() { try { if(rule.cssRules) { CSSUsage.PropertyValuesAnalyzer.anaylzeStyleOfRulePropCount(rule, selectedAtruleUsage); - processNestedAtRules(rule.cssRules, selectedAtruleUsage); } processConditionText(rule.conditionText, selectedAtruleUsage.conditions); @@ -349,9 +348,9 @@ void function() { try { * of the @atrule in question. */ function processConditionText(conditionText, selectedAtruleConditionalUsage) { - conditionText = conditionText.replace(/[0-9]/g, ''); - conditionText = conditionText.replace(".px", "px"); - conditionText = conditionText.replace(".em", "px"); + // replace numeric specific information from condition statements + conditionText = conditionText.replace(/[0-9]+.*[0-9]+/g, ''); + if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -361,41 +360,6 @@ void function() { try { } } - /** - * This processes the usage of nested atrules within other at rules. - */ - function processNestedAtRules(cssRules, selectedAtruleConditionalUsage) { - for(let index in cssRules) { - let ruleBody = cssRules[index]; - - - if(!ruleBody.cssText) { - continue; - } - - // only collect stats for sub atrules - if(!isRuleAnAtRule(ruleBody)) { - continue; - } - - var nestRuleSelector = nestRuleSelector = '@atrule:' + ruleBody.type; - - if(!selectedAtruleConditionalUsage["nested"]) { - selectedAtruleConditionalUsage["nested"] = Object.create(null); - } - - var nestedUsage = selectedAtruleConditionalUsage["nested"]; - - if(!nestedUsage[nestRuleSelector]) { - nestedUsage[nestRuleSelector] = Object.create(null); - nestedUsage[nestRuleSelector] = { "count": 1 } - } else { - var nestedCount = nestedUsage[nestRuleSelector].count; - nestedUsage[nestRuleSelector].count = nestedCount + 1; - } - } - } - /** * This will process all other @atrules that don't have conditions or styles. * [1] It will process any props and values used within the body of the rule. @@ -419,6 +383,7 @@ void function() { try { processKeyframeAtRules(rule); } else if(CSSUsageResults.rules[selectorText].props) { atrulesUsage[selectorText].props = CSSUsageResults.rules[selectorText].props; + delete atrulesUsage[selectorText].props.values; } } @@ -440,6 +405,7 @@ void function() { try { * WARN: tightly coupled with previous processing of rules. */ atrulesUsageForSelector.props = CSSUsageResults.rules["@atrule:8"].props; + delete atrulesUsageForSelector.props.values; for(let index in rule.cssRules) { let keyframe = rule.cssRules[index]; From 40a056b8232b50938dfc02d0c12725ba45abc50f Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Tue, 17 Oct 2017 12:26:51 -0700 Subject: [PATCH 7/8] removed logging and TODOs --- Recipe.min.js | 5 ++--- cssUsage.src.js | 5 ++--- src/cssUsage.js | 5 ++--- 3 files changed, 6 insertions(+), 9 deletions(-) diff --git a/Recipe.min.js b/Recipe.min.js index c0690c8..73c1433 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -847,7 +847,7 @@ void function() { try { function processConditionText(conditionText, selectedAtruleConditionalUsage) { // replace numeric specific information from condition statements conditionText = conditionText.replace(/[0-9]+.*[0-9]+/g, ''); - + if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -1755,8 +1755,7 @@ void function() { try { CSSUsageResults.usages = results; deleteDuplicatedAtRules(); // TODO: issue #52 - - console.log(CSSUsageResults); + if(window.debugCSSUsage) if(window.debugCSSUsage) console.log(CSSUsageResults.usages); } diff --git a/cssUsage.src.js b/cssUsage.src.js index f867fee..aaa88e4 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -847,7 +847,7 @@ void function() { try { function processConditionText(conditionText, selectedAtruleConditionalUsage) { // replace numeric specific information from condition statements conditionText = conditionText.replace(/[0-9]+.*[0-9]+/g, ''); - + if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -1755,8 +1755,7 @@ void function() { try { CSSUsageResults.usages = results; deleteDuplicatedAtRules(); // TODO: issue #52 - - console.log(CSSUsageResults); + if(window.debugCSSUsage) if(window.debugCSSUsage) console.log(CSSUsageResults.usages); } diff --git a/src/cssUsage.js b/src/cssUsage.js index 0737dc4..08ebef1 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -350,7 +350,7 @@ void function() { try { function processConditionText(conditionText, selectedAtruleConditionalUsage) { // replace numeric specific information from condition statements conditionText = conditionText.replace(/[0-9]+.*[0-9]+/g, ''); - + if(!selectedAtruleConditionalUsage[conditionText]) { selectedAtruleConditionalUsage[conditionText] = Object.create(null); selectedAtruleConditionalUsage[conditionText] = {"count": 1} @@ -1258,8 +1258,7 @@ void function() { try { CSSUsageResults.usages = results; deleteDuplicatedAtRules(); // TODO: issue #52 - - console.log(CSSUsageResults); + if(window.debugCSSUsage) if(window.debugCSSUsage) console.log(CSSUsageResults.usages); } From 9659d0c1e12ddaad2b3286cc68f6a820443dc9c5 Mon Sep 17 00:00:00 2001 From: tanhakabir Date: Tue, 17 Oct 2017 14:38:11 -0700 Subject: [PATCH 8/8] quick last fix --- Recipe.min.js | 14 ++++++-------- cssUsage.src.js | 14 ++++++-------- src/cssUsage.js | 14 ++++++-------- 3 files changed, 18 insertions(+), 24 deletions(-) diff --git a/Recipe.min.js b/Recipe.min.js index 73c1433..73db83a 100644 --- a/Recipe.min.js +++ b/Recipe.min.js @@ -912,15 +912,13 @@ void function() { try { continue; } - var frames = keyframe.keyText.split(', '); + var frame = keyframe.keyText; - for (let frame of frames) { - if(!atrulesUsageForKeyframeOfSelector[frame]) { - atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; - } else { - var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; - atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; - } + if(!atrulesUsageForKeyframeOfSelector[frame]) { + atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; + } else { + var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; + atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; } } } diff --git a/cssUsage.src.js b/cssUsage.src.js index aaa88e4..000bc3d 100644 --- a/cssUsage.src.js +++ b/cssUsage.src.js @@ -912,15 +912,13 @@ void function() { try { continue; } - var frames = keyframe.keyText.split(', '); + var frame = keyframe.keyText; - for (let frame of frames) { - if(!atrulesUsageForKeyframeOfSelector[frame]) { - atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; - } else { - var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; - atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; - } + if(!atrulesUsageForKeyframeOfSelector[frame]) { + atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; + } else { + var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; + atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; } } } diff --git a/src/cssUsage.js b/src/cssUsage.js index 08ebef1..b8700c3 100644 --- a/src/cssUsage.js +++ b/src/cssUsage.js @@ -415,15 +415,13 @@ void function() { try { continue; } - var frames = keyframe.keyText.split(', '); + var frame = keyframe.keyText; - for (let frame of frames) { - if(!atrulesUsageForKeyframeOfSelector[frame]) { - atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; - } else { - var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; - atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; - } + if(!atrulesUsageForKeyframeOfSelector[frame]) { + atrulesUsageForKeyframeOfSelector[frame] = { "count" : 1 }; + } else { + var keyframeCount = atrulesUsageForKeyframeOfSelector[frame].count; + atrulesUsageForKeyframeOfSelector[frame].count = keyframeCount + 1; } } }