@tbela99/css-parser 1.4.1 → 1.4.3

package/dist/lib/validation/config.d.ts

@@ -0,0 +1,14 @@
+import type { ValidationConfiguration } from "../../@types/validation.d.ts";
+import type { ValidationToken } from "./parser/types.d.ts";
+export interface ValidationSyntaxRule {
+    acceptAnyDeclarations: boolean;
+    acceptAnyRules: boolean;
+    getRules: () => ValidationToken[];
+    getBlockRules: () => ValidationToken[] | null;
+    getPreludeRules: () => ValidationToken[] | null;
+    getPropertyDescriptors: () => Record<string, ValidationToken[]> | null;
+}
+export declare function getSyntaxConfig(): ValidationConfiguration;
+export declare const getSyntax: (...args: any[]) => any;
+export declare const getParsedSyntax: (...args: any[]) => any;
+export declare const getSyntaxRule: (...args: any[]) => any;

package/dist/lib/validation/config.js

@@ -1,40 +1,22 @@
 import config from './config.json.js';
-import { parseSyntax } from './parser/parse.js';
+import { trimSyntaxArray, parseSyntax } from './parser/parse.js';
+import { ValidationTokenEnum } from './parser/typedef.js';
+import { memoize } from '../parser/utils/cache.js';
 
 const parsedSyntaxes = new Map();
 Object.freeze(config);
 function getSyntaxConfig() {
-    // @ts-ignore
+    // @ts-expect-error
     return config;
 }
-function getSyntax(group, key) {
-    // @ts-ignore
+function findNode(group, key) {
+    // @ts-expect-error
     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];
-                }
-            }
-        }
-        // @ts-ignore
-        obj = obj[key];
-    }
-    // @ts-ignore
-    return obj?.syntax ?? null;
-}
-function getParsedSyntax(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) == '-') {
+            if ((i == 0 && key.charAt(0) == "@") || key.charAt(0) == "-") {
                 const matches = key.match(/^(@?)(-[a-zA-Z]+)-(.*?)$/);
                 if (matches != null) {
                     key = matches[1] + matches[3];
@@ -44,17 +26,74 @@ function getParsedSyntax(group, key) {
                 return null;
             }
         }
-        // @ts-ignore
+        // @ts-expect-error
         obj = obj[key];
     }
-    const index = group + '.' + keys.join('.');
-    // @ts-ignore
+    return obj;
+}
+const getParsedSyntax = memoize((group, key) => {
+    // @ts-expect-error
+    const obj = findNode(group, key);
+    if (obj == null) {
+        return null;
+    }
+    const keys = Array.isArray(key) ? key : [key];
+    const index = group + "." + keys.join(".");
     if (!parsedSyntaxes.has(index)) {
-        const syntax = parseSyntax(obj.syntax);
-        // @ts-ignore
-        parsedSyntaxes.set(index, syntax.chi);
+        const syntax = Object.freeze(trimSyntaxArray(parseSyntax(obj.syntax)));
+        parsedSyntaxes.set(index, syntax);
     }
     return parsedSyntaxes.get(index);
-}
+});
+const getSyntaxRule = memoize((group, key) => {
+    const node = findNode(group, key);
+    if (node == null) {
+        return null;
+    }
+    let syntaxRules = getParsedSyntax(group, key);
+    if (syntaxRules == null) {
+        return null;
+    }
+    let blockStart = -1;
+    let blockEnd = -1;
+    let i;
+    for (i = 0; i < syntaxRules.length; i++) {
+        if (syntaxRules[i].typ === ValidationTokenEnum.OpenCurlyBrace ||
+            syntaxRules[i].typ === ValidationTokenEnum.SemiColon) {
+            blockStart = i;
+            break;
+        }
+    }
+    if (blockStart != -1) {
+        i = syntaxRules.length;
+        while (i--) {
+            if (syntaxRules[i].typ === ValidationTokenEnum.CloseCurlyBrace) {
+                blockEnd = i;
+                break;
+            }
+        }
+    }
+    const block = blockStart == -1 ? null : trimSyntaxArray(syntaxRules.slice(blockStart + 1, blockEnd));
+    const prelude = trimSyntaxArray(blockStart == -1 ? syntaxRules.slice() : syntaxRules.slice(0, blockStart));
+    let propertyDescriptors = null;
+    // @ts-expect-error
+    if (node.descriptors != null) {
+        propertyDescriptors = {};
+        // @ts-expect-error
+        for (const [key, value] of Object.entries(node.descriptors)) {
+            // @ts-expect-error
+            propertyDescriptors[key] = parseSyntax(typeof value === "string" ? value : value.syntax);
+        }
+    }
+    return {
+        acceptAnyDeclarations: node.syntax.includes("<declaration-list>"),
+        acceptAnyRules: node.syntax.includes("<group-rule-body>") ||
+            node.syntax.includes("<stylesheet>"),
+        getPreludeRules: () => prelude,
+        getBlockRules: () => (block == null || block.length === 0 ? null : block),
+        getRules: () => syntaxRules,
+        getPropertyDescriptors: () => propertyDescriptors,
+    };
+});
 
-export { getParsedSyntax, getSyntax, getSyntaxConfig };
+export { getParsedSyntax, getSyntaxConfig, getSyntaxRule };