@tbela99/css-parser 0.9.1 → 1.1.0

package/dist/lib/validation/at-rules/when.js

@@ -1,10 +1,11 @@
-import { ValidationLevel, EnumToken } from '../../ast/types.js';
+import { SyntaxValidationResult, EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../../ast/walk.js';
 import '../../parser/parse.js';
-import '../../renderer/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
+import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
+import { generalEnclosedFunc } from '../../renderer/color/utils/constants.js';
+import '../../renderer/sourcemap/lib/encode.js';
 import { consumeWhitespace } from '../utils/whitespace.js';
 import { splitTokenList } from '../utils/list.js';
 import { validateMediaFeature, validateMediaCondition } from './media.js';
@@ -16,8 +17,8 @@ function validateAtRuleWhen(atRule, options, root) {
     if (slice.length == 0) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
-            matches: [],
+            valid: SyntaxValidationResult.Valid,
+            context: [],
             node: atRule,
             syntax: '@when',
             error: '',
@@ -25,14 +26,14 @@ function validateAtRuleWhen(atRule, options, root) {
         };
     }
     const result = validateAtRuleWhenQueryList(atRule.tokens, atRule);
-    if (result.valid == ValidationLevel.Drop) {
+    if (result.valid == SyntaxValidationResult.Drop) {
         return result;
     }
     if (!('chi' in atRule)) {
         // @ts-ignore
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             node: atRule,
             syntax: '@when',
             error: 'expected at-rule body',
@@ -40,12 +41,11 @@ function validateAtRuleWhen(atRule, options, root) {
         };
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@when',
-        error: '',
-        tokens: result.tokens
+        error: ''
     };
 }
 // media() = media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )
@@ -61,10 +61,10 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
             continue;
         }
         while (split.length > 0) {
-            if (split[0].typ != EnumToken.FunctionTokenType || !['media', 'supports', 'font-tech', 'font-format'].includes(split[0].val)) {
+            if (split[0].typ != EnumToken.FunctionTokenType || !generalEnclosedFunc.includes(split[0].val)) {
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: split[0] ?? atRule,
                     syntax: '@when',
                     error: 'unexpected token',
@@ -78,26 +78,24 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
                 // result = valida
                 if (chi.length != 1 || !(validateMediaFeature(chi[0]) || validateMediaCondition(split[0], atRule))) {
                     result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: split[0] ?? atRule,
                         syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
-                        error: 'unexpected token',
-                        tokens: []
+                        error: 'unexpected token'
                     };
                     break;
                 }
             }
-            else if (['supports', 'font-tech', 'font-format'].includes(split[0].val)) {
+            else if (generalEnclosedFunc.includes(split[0].val)) {
                 // result = valida
                 if (!validateSupportCondition(atRule, split[0])) {
                     result = {
-                        valid: ValidationLevel.Drop,
-                        matches: [],
+                        valid: SyntaxValidationResult.Drop,
+                        context: [],
                         node: split[0] ?? atRule,
                         syntax: 'media( [ <mf-plain> | <mf-boolean> | <mf-range> ] )',
-                        error: 'unexpected token',
-                        tokens: []
+                        error: 'unexpected token'
                     };
                     break;
                 }
@@ -112,8 +110,8 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
             }
             if (![EnumToken.MediaFeatureAndTokenType, EnumToken.MediaFeatureOrTokenType].includes(split[0].typ)) {
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: split[0] ?? atRule,
                     syntax: '@when',
                     error: 'expecting and/or media-condition',
@@ -128,8 +126,8 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
             consumeWhitespace(split);
             if (split.length == 0) {
                 result = {
-                    valid: ValidationLevel.Drop,
-                    matches: [],
+                    valid: SyntaxValidationResult.Drop,
+                    context: [],
                     node: split[0] ?? atRule,
                     syntax: '@when',
                     error: 'expecting media-condition',
@@ -147,13 +145,12 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
     }
     if (matched.length == 0) {
         return {
-            valid: ValidationLevel.Drop,
-            matches: [],
+            valid: SyntaxValidationResult.Drop,
+            context: [],
             // @ts-ignore
             node: result?.node ?? atRule,
             syntax: '@when',
-            error: 'invalid at-rule body',
-            tokens: []
+            error: 'invalid at-rule body'
         };
     }
     tokenList.length = 0;
@@ -166,12 +163,11 @@ function validateAtRuleWhenQueryList(tokenList, atRule) {
         tokenList.push(...match);
     }
     return {
-        valid: ValidationLevel.Valid,
-        matches: [],
+        valid: SyntaxValidationResult.Valid,
+        context: [],
         node: atRule,
         syntax: '@when',
-        error: '',
-        tokens: tokenList
+        error: ''
     };
 }
 

package/dist/lib/validation/atrule.js

@@ -1,10 +1,11 @@
-import { ValidationLevel, EnumToken } from '../ast/types.js';
+import { SyntaxValidationResult, EnumToken } from '../ast/types.js';
 import '../ast/minify.js';
 import '../ast/walk.js';
 import '../parser/parse.js';
+import '../parser/tokenize.js';
+import '../parser/utils/config.js';
 import '../renderer/color/utils/constants.js';
 import '../renderer/sourcemap/lib/encode.js';
-import '../parser/utils/config.js';
 import { getSyntaxConfig, getParsedSyntax } from './config.js';
 import { validateAtRuleMedia } from './at-rules/media.js';
 import { validateAtRuleCounterStyle } from './at-rules/counter-style.js';
@@ -16,7 +17,6 @@ import { validateAtRuleLayer } from './at-rules/layer.js';
 import { validateAtRuleFontFeatureValues } from './at-rules/font-feature-values.js';
 import { validateAtRuleNamespace } from './at-rules/namespace.js';
 import { validateAtRuleDocument } from './at-rules/document.js';
-import { validateAtRuleKeyframes } from './at-rules/keyframes.js';
 import { validateAtRuleWhen } from './at-rules/when.js';
 import { validateAtRuleElse } from './at-rules/else.js';
 import { validateAtRuleContainer } from './at-rules/container.js';
@@ -26,18 +26,15 @@ function validateAtRule(atRule, options, root) {
     if (atRule.nam == 'charset') {
         const valid = atRule.val.match(/^"[a-zA-Z][a-zA-Z0-9_-]+"$/i) != null;
         return {
-            valid: valid ? ValidationLevel.Valid : ValidationLevel.Drop,
+            valid: valid ? SyntaxValidationResult.Valid : SyntaxValidationResult.Drop,
             node: atRule,
             syntax: null,
             error: ''
         };
     }
-    if (atRule.nam == 'keyframes') {
-        return validateAtRuleKeyframes(atRule);
-    }
     if (['font-face', 'view-transition', 'starting-style'].includes(atRule.nam)) {
         return {
-            valid: ValidationLevel.Valid,
+            valid: SyntaxValidationResult.Valid,
             node: atRule,
             syntax: '@' + atRule.nam,
             error: ''
@@ -82,7 +79,7 @@ function validateAtRule(atRule, options, root) {
     if (['position-try', 'property', 'font-palette-values'].includes(atRule.nam)) {
         if (!('tokens' in atRule)) {
             return {
-                valid: ValidationLevel.Drop,
+                valid: SyntaxValidationResult.Drop,
                 node: atRule,
                 syntax: '@' + atRule.nam,
                 error: 'expected prelude'
@@ -90,7 +87,7 @@ function validateAtRule(atRule, options, root) {
         }
         if (!('chi' in atRule)) {
             return {
-                valid: ValidationLevel.Drop,
+                valid: SyntaxValidationResult.Drop,
                 node: atRule,
                 syntax: '@' + atRule.nam,
                 error: 'expected body'
@@ -99,7 +96,7 @@ function validateAtRule(atRule, options, root) {
         const chi = atRule.tokens.filter((t) => t.typ != EnumToken.WhitespaceTokenType && t.typ != EnumToken.CommentTokenType);
         if (chi.length != 1) {
             return {
-                valid: ValidationLevel.Drop,
+                valid: SyntaxValidationResult.Drop,
                 node: atRule,
                 syntax: '@' + atRule.nam,
                 error: 'expected ' + (atRule.nam == 'property' ? 'custom-property-name' : 'dashed-ident')
@@ -108,7 +105,7 @@ function validateAtRule(atRule, options, root) {
         if (chi[0].typ != EnumToken.DashedIdenTokenType) {
             // @ts-ignore
             return {
-                valid: ValidationLevel.Drop,
+                valid: SyntaxValidationResult.Drop,
                 node: atRule,
                 syntax: '@' + atRule.nam,
                 error: 'expected ' + (atRule.nam == 'property' ? 'custom-property-name' : 'dashed-ident')
@@ -116,7 +113,7 @@ function validateAtRule(atRule, options, root) {
         }
         // @ts-ignore
         return {
-            valid: ValidationLevel.Valid,
+            valid: SyntaxValidationResult.Valid,
             node: atRule,
             syntax: '@' + atRule.nam,
             error: ''
@@ -130,7 +127,7 @@ function validateAtRule(atRule, options, root) {
         if (!(root == null || (root.typ == EnumToken.AtRuleNodeType && root.nam == 'page'))) {
             // @ts-ignore
             return {
-                valid: ValidationLevel.Drop,
+                valid: SyntaxValidationResult.Drop,
                 node: atRule,
                 syntax: '@page',
                 error: 'not allowed here'
@@ -150,14 +147,14 @@ function validateAtRule(atRule, options, root) {
     if (!(name in config.atRules)) {
         if (options.lenient) {
             return {
-                valid: ValidationLevel.Lenient,
+                valid: SyntaxValidationResult.Lenient,
                 node: atRule,
                 syntax: null,
                 error: ''
             };
         }
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             node: atRule,
             syntax: null,
             error: 'unknown at-rule'
@@ -166,7 +163,7 @@ function validateAtRule(atRule, options, root) {
     const syntax = getParsedSyntax("atRules" /* ValidationSyntaxGroupEnum.AtRules */, name)?.[0];
     if ('chi' in syntax && !('chi' in atRule)) {
         return {
-            valid: ValidationLevel.Drop,
+            valid: SyntaxValidationResult.Drop,
             node: atRule,
             syntax,
             error: 'missing at-rule body'
@@ -177,7 +174,7 @@ function validateAtRule(atRule, options, root) {
     //     return validateSyntax(syntax.prelude as ValidationToken[], atRule.tokens as Token[], root, options);
     // }
     return {
-        valid: ValidationLevel.Valid,
+        valid: SyntaxValidationResult.Valid,
         node: null,
         syntax,
         error: ''

package/dist/lib/validation/config.js

@@ -8,6 +8,29 @@ function getSyntaxConfig() {
     // @ts-ignore
     return config;
 }
+function getSyntax(group, key) {
+    // @ts-ignore
+    let obj = config[group];
+    const keys = Array.isArray(key) ? key : [key];
+    for (let i = 0; i < keys.length; i++) {
+        key = keys[i];
+        if (!(key in obj)) {
+            if ((i == 0 && key.charAt(0) == '@') || key.charAt(0) == '-') {
+                const matches = key.match(/^(@?)(-[a-zA-Z]+)-(.*?)$/);
+                if (matches != null) {
+                    key = matches[1] + matches[3];
+                }
+            }
+            if (!(key in obj)) {
+                return null;
+            }
+        }
+        // @ts-ignore
+        obj = obj[key];
+    }
+    // @ts-ignore
+    return obj?.syntax ?? null;
+}
 function getParsedSyntax(group, key) {
     // @ts-ignore
     let obj = config[group];
@@ -39,4 +62,4 @@ function getParsedSyntax(group, key) {
     return parsedSyntaxes.get(index);
 }
 
-export { getParsedSyntax, getSyntaxConfig };
+export { getParsedSyntax, getSyntax, getSyntaxConfig };