@tbela99/css-parser 0.2.0 → 0.4.0

package/dist/lib/parser/declaration/map.js

@@ -1,15 +1,13 @@
 import { eq } from '../utils/eq.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/utils/color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { parseString } from '../parse.js';
+import '../../renderer/color/utils/constants.js';
 import { getConfig } from '../utils/config.js';
 import { matchType } from '../utils/type.js';
 import { PropertySet } from './set.js';
-import { IterableWeakMap } from '../../iterable/weakmap.js';
 
-const cache = new IterableWeakMap();
 const propertiesConfig = getConfig();
 class PropertyMap {
     config;
@@ -24,12 +22,10 @@ class PropertyMap {
         this.pattern = config.pattern.split(/\s/);
     }
     add(declaration) {
-        for (const val of declaration.val) {
-            Object.defineProperty(val, 'propertyName', { enumerable: false, writable: true, value: declaration.nam });
-        }
         if (declaration.nam == this.config.shorthand) {
             this.declarations = new Map;
             this.declarations.set(declaration.nam, declaration);
+            this.matchTypes(declaration);
         }
         else {
             const separator = this.config.separator != null ? {
@@ -167,6 +163,55 @@ class PropertyMap {
         }
         return this;
     }
+    matchTypes(declaration) {
+        const patterns = this.pattern.slice();
+        const values = [...declaration.val];
+        let i;
+        let j;
+        const map = new Map;
+        for (i = 0; i < patterns.length; i++) {
+            for (j = 0; j < values.length; j++) {
+                if (!map.has(patterns[i])) {
+                    // @ts-ignore
+                    map.set(patterns[i], this.config.properties?.[patterns[i]]?.constraints?.mapping?.max ?? 1);
+                }
+                let count = map.get(patterns[i]);
+                if (count > 0 && matchType(values[j], this.config.properties[patterns[i]])) {
+                    Object.defineProperty(values[j], 'propertyName', {
+                        enumerable: false,
+                        writable: true,
+                        value: patterns[i]
+                    });
+                    map.set(patterns[i], --count);
+                    values.splice(j--, 1);
+                }
+            }
+        }
+        if (this.config.set != null) {
+            for (const [key, val] of Object.entries(this.config.set)) {
+                if (map.has(key)) {
+                    for (const v of val) {
+                        // missing
+                        if (map.get(v) == 1) {
+                            let i = declaration.val.length;
+                            while (i--) {
+                                // @ts-ignore
+                                if (declaration.val[i].propertyName == key) {
+                                    const val = { ...declaration.val[i] };
+                                    Object.defineProperty(val, 'propertyName', {
+                                        enumerable: false,
+                                        writable: true,
+                                        value: v
+                                    });
+                                    declaration.val.splice(i, 0, val, { typ: EnumToken.WhitespaceTokenType });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     [Symbol.iterator]() {
         let iterable;
         let requiredCount = 0;
@@ -195,22 +240,62 @@ class PropertyMap {
         }
         if (!isShorthand || requiredCount < this.requiredCount) {
             if (isShorthand && this.declarations.has(this.config.shorthand)) {
-                // console.debug(...this.declarations.values());
+                const cache = new Map();
                 const removeDefaults = (declaration) => {
-                    // const dec: AstDeclaration = {...declaration};
-                    const config = this.config.shorthand == declaration.nam ? this.config : this.config.properties[declaration.nam];
-                    declaration.val = declaration.val.filter((val) => {
-                        if (!cache.has(val)) {
-                            cache.set(val, renderToken(val, { minify: true }));
+                    let i;
+                    let t;
+                    let map = new Map();
+                    let value = [];
+                    let values = [];
+                    // @ts-ignore
+                    let typ = (EnumToken[this.config.separator?.typ] ?? EnumToken.CommaTokenType);
+                    let separator = this.config.separator ? renderToken(this.config.separator) : ',';
+                    this.matchTypes(declaration);
+                    values.push(value);
+                    for (i = 0; i < declaration.val.length; i++) {
+                        t = declaration.val[i];
+                        if (!cache.has(t)) {
+                            cache.set(t, renderToken(t, { minify: true }));
+                        }
+                        if (t.typ == typ && separator == cache.get(t)) {
+                            this.removeDefaults(map, value);
+                            value = [];
+                            values.push(value);
+                            map.clear();
+                            continue;
+                        }
+                        value.push(t);
+                        // @ts-ignore
+                        if ('propertyName' in t) {
+                            // @ts-ignore
+                            if (!map.has(t.propertyName)) {
+                                // @ts-ignore
+                                map.set(t.propertyName, { t: [t], value: [cache.get(t)] });
+                            }
+                            else {
+                                // @ts-ignore
+                                const v = map.get(t.propertyName);
+                                v.t.push(t);
+                                v.value.push(cache.get(t));
+                            }
                         }
-                        return !config.default.includes(cache.get(val));
-                    })
-                        .filter((val, index, array) => !(index > 0 &&
-                        val.typ == EnumToken.WhitespaceTokenType &&
-                        array[index - 1].typ == EnumToken.WhitespaceTokenType));
-                    if (declaration.val.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
+                    }
+                    this.removeDefaults(map, value);
+                    declaration.val = values.reduce((acc, curr) => {
+                        for (const cr of curr) {
+                            if (cr.typ == EnumToken.WhitespaceTokenType && acc.at(-1)?.typ == cr.typ) {
+                                continue;
+                            }
+                            acc.push(cr);
+                        }
+                        return acc;
+                    }, []);
+                    while (declaration.val.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
                         declaration.val.pop();
                     }
+                    while (declaration.val.at(0)?.typ == EnumToken.WhitespaceTokenType) {
+                        declaration.val.shift();
+                    }
                     return declaration;
                 };
                 const values = [...this.declarations.values()].reduce((acc, curr) => {
@@ -222,13 +307,24 @@ class PropertyMap {
                     }
                     return acc;
                 }, []);
-                const filtered = values.map(removeDefaults).filter((x) => x.val.length > 0);
+                let isImportant = false;
+                const filtered = values.map(removeDefaults).filter((x) => x.val.filter((t) => {
+                    if (t.typ == EnumToken.ImportantTokenType) {
+                        isImportant = true;
+                    }
+                    return ![EnumToken.WhitespaceTokenType, EnumToken.ImportantTokenType].includes(t.typ);
+                }).length > 0);
                 if (filtered.length == 0 && this.config.default.length > 0) {
                     filtered.push({
                         typ: EnumToken.DeclarationNodeType,
                         nam: this.config.shorthand,
                         val: parseString(this.config.default[0])
                     });
+                    if (isImportant) {
+                        filtered[0].val.push({
+                            typ: EnumToken.ImportantTokenType
+                        });
+                    }
                 }
                 return (filtered.length > 0 ? filtered : values)[Symbol.iterator]();
             }
@@ -299,12 +395,12 @@ class PropertyMap {
                 return acc;
             }, []);
             count++;
-            if (!isShorthand || Object.entries(this.config.properties).some(entry => {
+            if (!isShorthand || Object.entries(this.config.properties).some((entry) => {
                 // missing required property
                 return entry[1].required && !(entry[0] in tokens);
             }) ||
                 // @ts-ignore
-                !Object.values(tokens).every(v => v.filter(t => t.typ != EnumToken.CommentTokenType).length == count)) {
+                !Object.values(tokens).every((v) => v.filter((t) => t.typ != EnumToken.CommentTokenType).length == count)) {
                 // @ts-ignore
                 iterable = this.declarations.values();
             }
@@ -324,7 +420,9 @@ class PropertyMap {
                         }, []);
                         // @todo remove renderToken call
                         if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
-                            continue;
+                            if (!this.config.properties[curr[0]].required) {
+                                continue;
+                            }
                         }
                         // remove default values
                         let doFilterDefault = true;
@@ -338,12 +436,15 @@ class PropertyMap {
                             }
                         }
                         // remove default values
-                        values = values.filter((val) => {
+                        const filtered = values.filter((val) => {
                             if (val.typ == EnumToken.WhitespaceTokenType || val.typ == EnumToken.CommentTokenType) {
                                 return false;
                             }
                             return !doFilterDefault || !(val.typ == EnumToken.IdenTokenType && props.default.includes(val.val));
                         });
+                        if (filtered.length > 0 || !(this.requiredCount == requiredCount && this.config.properties[curr[0]].required)) {
+                            values = filtered;
+                        }
                         if (values.length > 0) {
                             if ('mapping' in props) {
                                 // @ts-ignore
@@ -399,7 +500,10 @@ class PropertyMap {
                     return acc;
                 }, []);
                 if (this.config.mapping != null) {
-                    const val = values.reduce((acc, curr) => acc + renderToken(curr, { removeComments: true, minify: true }), '');
+                    const val = values.reduce((acc, curr) => acc + renderToken(curr, {
+                        removeComments: true,
+                        minify: true
+                    }), '');
                     if (val in this.config.mapping) {
                         values.length = 0;
                         values.push({
@@ -451,6 +555,36 @@ class PropertyMap {
             }
         };
     }
+    removeDefaults(map, value) {
+        for (const [key, val] of map) {
+            const config = this.config.properties[key];
+            if (config == null) {
+                continue;
+            }
+            const v = val.value.join(' ');
+            if (config.default.includes(v) || (value.length == 1 && this.config.default.includes(v))) {
+                for (const token of value) {
+                    if (val.t.includes(token)) {
+                        let index = value.indexOf(token);
+                        value.splice(index, 1);
+                        if (config.prefix != null) {
+                            while (index-- > 0) {
+                                if (value[index].typ == EnumToken.WhitespaceTokenType) {
+                                    continue;
+                                }
+                                if (value[index].typ == EnumToken[config.prefix.typ] &&
+                                    // @ts-ignore
+                                    value[index].val == config.prefix.val) {
+                                    value.splice(index, 1);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 export { PropertyMap };

package/dist/lib/parser/declaration/set.js

@@ -3,9 +3,32 @@ import { isLength } from '../utils/syntax.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../parse.js';
-import '../../renderer/utils/color.js';
+import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
+function dedup(values) {
+    for (const value of values) {
+        let i = value.length;
+        while (i-- > 1) {
+            const t = value[i];
+            const k = value[i == 1 ? 0 : i % 2];
+            if (t.val == k.val && t.val == '0') {
+                if ((t.typ == EnumToken.NumberTokenType && isLength(k)) ||
+                    (k.typ == EnumToken.NumberTokenType && isLength(t)) ||
+                    (isLength(k) || isLength(t))) {
+                    value.splice(i, 1);
+                    continue;
+                }
+            }
+            if (eq(t, k)) {
+                value.splice(i, 1);
+                continue;
+            }
+            break;
+        }
+    }
+    return values;
+}
 class PropertySet {
     config;
     declarations;
@@ -100,7 +123,23 @@ class PropertySet {
         let iterator;
         const declarations = this.declarations;
         if (declarations.size < this.config.properties.length) {
-            iterator = declarations.values();
+            const values = [...declarations.values()];
+            if (this.isShortHand()) {
+                const val = values[0].val.reduce((acc, curr) => {
+                    if (![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(curr.typ)) {
+                        acc.push(curr);
+                    }
+                    return acc;
+                }, []);
+                values[0].val = val.reduce((acc, curr) => {
+                    if (acc.length > 0) {
+                        acc.push({ typ: EnumToken.WhitespaceTokenType });
+                    }
+                    acc.push(curr);
+                    return acc;
+                }, []);
+            }
+            return values[Symbol.iterator]();
         }
         else {
             const values = [];
@@ -118,26 +157,7 @@ class PropertySet {
                     index++;
                 }
             });
-            for (const value of values) {
-                let i = value.length;
-                while (i-- > 1) {
-                    const t = value[i];
-                    const k = value[i == 1 ? 0 : i % 2];
-                    if (t.val == k.val && t.val == '0') {
-                        if ((t.typ == EnumToken.NumberTokenType && isLength(k)) ||
-                            (k.typ == EnumToken.NumberTokenType && isLength(t)) ||
-                            (isLength(k) || isLength(t))) {
-                            value.splice(i, 1);
-                            continue;
-                        }
-                    }
-                    if (eq(t, k)) {
-                        value.splice(i, 1);
-                        continue;
-                    }
-                    break;
-                }
-            }
+            dedup(values);
             iterator = [{
                     typ: EnumToken.DeclarationNodeType,
                     nam: this.config.shorthand,