public string Keyframes(string css)
{
try
{
string preParseHash = css.GetStableHashCodeString();
if (!_cache.Seen.ContainsKey(preParseHash))
{
css = "@keyframes &{" + css.RemoveComments().RemoveDuplicateSpaces() + "}";
IList <ParsedClass> parsedClasses = css.GetClasses();
Task.Run(() => _scriptManager.UpdatedParsedClasses(_id.GetStableHashCodeString(), _id, _priority, parsedClasses));
if (!_cache.Seen.ContainsKey(preParseHash))
{
_cache.Seen.Add(preParseHash, parsedClasses.First().Hash);
}
return(parsedClasses.First().Hash);
}
else
{
return(_cache.Seen[preParseHash]);
}
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
public string Css(string className, string css)
{
try
{
css = css.RemoveComments().RemoveDuplicateSpaces();
IList <ParsedClass> parsedClasses = css.GetClasses(className);
if (parsedClasses.Count > 0)
{
string hash = parsedClasses.First().IsMediaQuery ? parsedClasses.First().ChildClasses.First().Name.Replace(".", string.Empty) : parsedClasses.First().Name;
Task.Run(() => _scriptManager.UpdatedParsedClasses(_id.GetStableHashCodeString(), _id, _priority, parsedClasses));
return(hash);
}
else
{
return(string.Empty);
}
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
public string Css(string css)
{
try
{
css = css.RemoveDuplicateSpaces();
RuleSet ruleSet = ParseRuleSet(css);
if (ruleSet.Declarations.Count > 0)
{
_styleSheet.AddClass(ruleSet, _id);
}
foreach (IRule nestedRuleSet in ruleSet.NestedRules)
{
_styleSheet.AddClass(nestedRuleSet, _id);
}
return(ruleSet.Selector);
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
private Keyframe ParseKeyframe(string css)
{
Keyframe keyframe = new Keyframe();
IRule current = keyframe;
string buffer = string.Empty;
bool nestedClassClosed = true;
foreach (char ch in css)
{
switch (ch)
{
case ';':
Declaration declaration = ParseDeclaration(buffer.Trim());
if (declaration != null)
{
current.Declarations.Add(declaration);
}
buffer = string.Empty;
break;
case '{':
IRule nestedClass;
nestedClass = new PredefinedRuleSet
{
Selector = buffer.Trim()
};
keyframe.NestedRules.Add(nestedClass);
buffer = string.Empty;
current = nestedClass;
nestedClassClosed = false;
break;
case '}':
nestedClassClosed = true;
break;
default:
buffer += ch;
break;
}
}
if (!nestedClassClosed)
{
throw StyledException.GetException(css, "A nested class is missing a '}' character", null);
}
if (buffer.Trim() != string.Empty)
{
throw StyledException.GetException(buffer, "This is usually caused by a missing ';' character at the end of a declaration", null);
}
keyframe.SetClassName();
return(keyframe);
}
public void Fontface(string css)
{
try
{
Css(css);
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
public async Task FontfaceAsync(string css)
{
try
{
await CssAsync(css);
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
public void Fontface(string css)
{
try
{
css = css.RemoveDuplicateSpaces();
FontFace fontface = ParseFontFace(css);
_styleSheet.AddClass(fontface, _id);
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
public string Keyframes(string css)
{
try
{
css = css.RemoveDuplicateSpaces();
Keyframe keyframe = ParseKeyframe(css);
_styleSheet.AddClass(keyframe, _id);
return(keyframe.Selector);
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
public string Keyframes(string css)
{
try
{
css = "@keyframes &{" + css.RemoveComments().RemoveDuplicateSpaces() + "}";
IList <ParsedClass> parsedClasses = css.GetClasses();
Task.Run(() => _scriptManager.UpdatedParsedClasses(_id.GetStableHashCodeString(), _id, _priority, parsedClasses));
return(parsedClasses.First().Hash);
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
public async Task <string> CssAsync(string className, string css)
{
try
{
string preParseHash = css.GetStableHashCodeString();
if (!_cache.Seen.ContainsKey(preParseHash))
{
css = css.RemoveComments().RemoveDuplicateSpaces();
IList <ParsedClass> parsedClasses = css.GetClasses(className);
if (parsedClasses.Count > 0)
{
string hash = parsedClasses.First().IsMediaQuery ? parsedClasses.First().ChildClasses.First().Name.Replace(".", string.Empty) : parsedClasses.First().Name;
await _scriptManager.UpdatedParsedClasses(_id.GetStableHashCodeString(), _id, _priority, parsedClasses);
if (!_cache.Seen.ContainsKey(preParseHash))
{
_cache.Seen.Add(preParseHash, hash);
}
return(hash);
}
else
{
if (!_cache.Seen.ContainsKey(preParseHash))
{
_cache.Seen.Add(preParseHash, string.Empty);
}
return(string.Empty);
}
}
else
{
return(_cache.Seen[preParseHash]);
}
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
private Declaration ParseDeclaration(string input)
{
if (string.IsNullOrEmpty(input))
{
return(null);
}
try
{
string property = input.Substring(0, input.IndexOf(':')).Trim();
string value = input.Substring(input.IndexOf(':') + 1).Trim();
return(new Declaration {
Property = property, Value = value
});
}
catch (Exception e)
{
throw StyledException.GetException(input, "This is likely cause by a missing ':' character", e);
}
}
public string Css(string className, string css)
{
try
{
css = css.RemoveDuplicateSpaces();
IRule rule;
if (className.IndexOf("@font-face") != -1)
{
rule = ParseFontFace(css);
_styleSheet.AddClass(rule, _id);
}
else if (className.IndexOf("@media") != -1)
{
rule = ParseMediaQuery(className, "{" + css + "}");
_styleSheet.AddClass(rule, _id);
}
else
{
rule = ParsePredefinedRuleSet(className, css);
if (_elements.Contains(className))
{
_styleSheet.AddClass(rule, _id);
}
else
{
_styleSheet.AddClass(rule, _id);
}
}
return(rule.Selector);
}
catch (StyledException e)
{
throw e;
}
catch (Exception e)
{
throw StyledException.GetException(css, e);
}
}
private RuleSet ParseRuleSet(string css)
{
RuleSet ruleSet = new RuleSet
{
Label = _id != DEFAULT ? _id : null
};
IRule current = ruleSet;
string buffer = string.Empty;
bool nestedClassClosed = true; //Start from true becuase the parent doesnt need to be closed
foreach (char ch in css)
{
switch (ch)
{
case ';':
Declaration declaration = ParseDeclaration(buffer.Trim());
if (declaration != null)
{
if (declaration.Property == "label")
{
current.Label = current.Label == null?declaration.Value.Trim() : $"{current.Label}-{declaration.Value.Trim()}";
}
else
{
current.Declarations.Add(declaration);
}
}
buffer = string.Empty;
break;
case '{':
IRule nestedClass;
if (buffer.IndexOf("@media") == -1)
{
nestedClass = new PredefinedRuleSet
{
Selector = buffer.Trim()
};
}
else
{
nestedClass = new MediaQuery
{
Selector = buffer.Trim() + "{&"
};
}
ruleSet.NestedRules.Add(nestedClass);
buffer = string.Empty;
current = nestedClass;
nestedClassClosed = false;
break;
case '}':
nestedClassClosed = true;
break;
default:
buffer += ch;
break;
}
}
if (!nestedClassClosed)
{
throw StyledException.GetException(css, "A nested class is missing a '}' character", null);
}
if (buffer.Trim() != string.Empty)
{
throw StyledException.GetException(buffer, "This is usually caused by a missing ';' character at the end of a declaration", null);
}
ruleSet.SetClassName();
return(ruleSet);
}
