@tbela99/css-parser 0.0.1-alpha5 → 0.0.1-rc2

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

@@ -1,6 +1,7 @@
 import { PropertySet } from './set.js';
 import { getConfig } from '../utils/config.js';
 import { PropertyMap } from './map.js';
+import { parseString } from '../parse.js';
 
 const config = getConfig();
 class PropertyList {
@@ -8,33 +9,61 @@ class PropertyList {
     constructor() {
         this.declarations = new Map;
     }
+    set(nam, value) {
+        return this.add({ typ: 'Declaration', nam, val: Array.isArray(value) ? value : parseString(String(value)) });
+    }
     add(declaration) {
         if (declaration.typ != 'Declaration') {
             this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
             return this;
         }
-        const propertyName = declaration.nam;
+        let propertyName = declaration.nam;
+        let shortHandType;
+        let shorthand;
         if (propertyName in config.properties) {
             // @ts-ignore
-            const shorthand = config.properties[propertyName].shorthand;
+            if ('map' in config.properties[propertyName]) {
+                shortHandType = 'map';
+                // @ts-ignore
+                shorthand = config.properties[propertyName].map;
+            }
+            else {
+                shortHandType = 'set';
+                // @ts-ignore
+                shorthand = config.properties[propertyName].shorthand;
+            }
+        }
+        else if (propertyName in config.map) {
+            shortHandType = 'map';
+            // @ts-ignore
+            shorthand = config.map[propertyName].shorthand;
+        }
+        // @ts-ignore
+        if (shortHandType == 'map') {
+            // @ts-ignore
             if (!this.declarations.has(shorthand)) {
                 // @ts-ignore
-                this.declarations.set(shorthand, new PropertySet(config.properties[shorthand]));
+                this.declarations.set(shorthand, new PropertyMap(config.map[shorthand]));
             }
+            // @ts-ignore
             this.declarations.get(shorthand).add(declaration);
-            return this;
+            // return this;
         }
-        if (propertyName in config.map) {
+        // @ts-ignore
+        else if (shortHandType == 'set') {
             // @ts-ignore
-            const shorthand = config.map[propertyName].shorthand;
+            // const shorthand: string = <string>config.properties[propertyName].shorthand;
             if (!this.declarations.has(shorthand)) {
                 // @ts-ignore
-                this.declarations.set(shorthand, new PropertyMap(config.map[shorthand]));
+                this.declarations.set(shorthand, new PropertySet(config.properties[shorthand]));
             }
+            // @ts-ignore
             this.declarations.get(shorthand).add(declaration);
-            return this;
+            // return this;
+        }
+        else {
+            this.declarations.set(propertyName, declaration);
         }
-        this.declarations.set(propertyName, declaration);
         return this;
     }
     [Symbol.iterator]() {

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

@@ -1,36 +1,11 @@
 import { eq } from '../utils/eq.js';
-import { isNumber } from '../utils/syntax.js';
+import { getConfig } from '../utils/config.js';
 import { renderToken } from '../../renderer/render.js';
 import { matchType } from '../utils/type.js';
+import { parseString } from '../parse.js';
+import { PropertySet } from './set.js';
 
-function getTokenType(val) {
-    if (val == 'transparent' || val == 'currentcolor') {
-        return {
-            typ: 'Color',
-            val,
-            kin: 'lit'
-        };
-    }
-    if (val.endsWith('%')) {
-        return {
-            typ: 'Perc',
-            val: val.slice(0, -1)
-        };
-    }
-    return {
-        typ: isNumber(val) ? 'Number' : 'Iden',
-        val
-    };
-}
-function parseString(val) {
-    return val.split(/\s/).map(getTokenType).reduce((acc, curr) => {
-        if (acc.length > 0) {
-            acc.push({ typ: 'Whitespace' });
-        }
-        acc.push(curr);
-        return acc;
-    }, []);
-}
+const propertiesConfig = getConfig();
 class PropertyMap {
     config;
     declarations;
@@ -45,7 +20,7 @@ class PropertyMap {
     }
     add(declaration) {
         if (declaration.nam == this.config.shorthand) {
-            this.declarations.clear();
+            this.declarations = new Map;
             this.declarations.set(declaration.nam, declaration);
         }
         else {
@@ -122,8 +97,7 @@ class PropertyMap {
                             const defaults = parseString(props.default[0]);
                             if (!(property in tokens)) {
                                 tokens[property] = [
-                                    [...defaults
-                                    ]
+                                    [...defaults]
                                 ];
                             }
                             else {
@@ -157,145 +131,229 @@ class PropertyMap {
                     }, new Map);
                 }
             }
-            this.declarations.set(declaration.nam, declaration);
+            // @ts-ignore
+            const config = propertiesConfig.properties[declaration.nam];
+            let property = declaration.nam;
+            if (config != null) {
+                property = config.shorthand;
+                let value = this.declarations.get(property);
+                if (!(value instanceof PropertySet)) {
+                    // @ts-ignore
+                    this.declarations.set(property, new PropertySet(propertiesConfig.properties[config.shorthand]));
+                    // Token[]
+                    if (value != null) {
+                        // @ts-ignore
+                        this.declarations.get(property).add(value);
+                    }
+                }
+                this.declarations.get(property).add(declaration);
+            }
+            else {
+                this.declarations.set(declaration.nam, declaration);
+            }
         }
         return this;
     }
     [Symbol.iterator]() {
-        let requiredCount = Object.keys(this.config.properties).reduce((acc, curr) => this.declarations.has(curr) && this.config.properties[curr].required ? ++acc : acc, 0);
-        if (requiredCount == 0) {
-            requiredCount = this.declarations.size;
-        }
-        if (requiredCount < this.requiredCount) {
-            // if (this.declarations.size == 1 && this.declarations.has(this.config.shorthand)) {
-            //
-            //     this.declarations
-            // }
-            return this.declarations.values();
-        }
-        let count = 0;
-        const separator = this.config.separator;
-        const tokens = {};
-        // @ts-ignore
-        const valid = Object.entries(this.config.properties).reduce((acc, curr) => {
-            if (!this.declarations.has(curr[0])) {
-                if (curr[1].required) {
-                    acc.push(curr[0]);
+        let iterable;
+        let requiredCount = 0;
+        let property;
+        let isShorthand = true;
+        for (property of Object.keys(this.config.properties)) {
+            if (this.config.properties[property].required) {
+                if (!this.declarations.has(property)) {
+                    isShorthand = false;
+                    break;
                 }
-                return acc;
-            }
-            let current = 0;
-            const props = this.config.properties[curr[0]];
-            // @ts-ignore
-            for (const val of this.declarations.get(curr[0]).val) {
-                if (separator != null && separator.typ == val.typ && eq(separator, val)) {
-                    current++;
-                    if (tokens[curr[0]].length == current) {
-                        tokens[curr[0]].push([]);
+                else {
+                    const val = this.declarations.get(property);
+                    if (val instanceof PropertySet && !val.isShortHand()) {
+                        isShorthand = false;
+                        break;
                     }
-                    continue;
-                }
-                if (val.typ == 'Whitespace' || val.typ == 'Comment') {
-                    continue;
-                }
-                if (props.multiple && props.separator != null && props.separator.typ == val.typ && eq(val, props.separator)) {
-                    continue;
-                }
-                if (matchType(val, curr[1])) {
-                    if (!(curr[0] in tokens)) {
-                        tokens[curr[0]] = [[]];
+                    else {
+                        requiredCount++;
                     }
-                    // is default value
-                    tokens[curr[0]][current].push(val);
-                    continue;
                 }
-                acc.push(curr[0]);
-                break;
             }
-            if (count == 0) {
-                count = current;
-            }
-            return acc;
-        }, []);
-        if (valid.length > 0 || Object.values(tokens).every(v => v.every(v => v.length == count))) {
-            return this.declarations.values();
         }
-        const values = Object.entries(tokens).reduce((acc, curr) => {
-            const props = this.config.properties[curr[0]];
-            for (let i = 0; i < curr[1].length; i++) {
-                if (acc.length == i) {
-                    acc.push([]);
-                }
-                let values = curr[1][i].reduce((acc, curr) => {
-                    if (acc.length > 0) {
-                        acc.push({ typ: 'Whitespace' });
+        if (requiredCount == 0) {
+            requiredCount = this.declarations.size;
+        }
+        if (!isShorthand || requiredCount < this.requiredCount) {
+            // @ts-ignore
+            iterable = this.declarations.values();
+        }
+        else {
+            let count = 0;
+            const separator = this.config.separator;
+            const tokens = {};
+            // @ts-ignore
+            /* const valid: string[] =*/ Object.entries(this.config.properties).reduce((acc, curr) => {
+                if (!this.declarations.has(curr[0])) {
+                    if (curr[1].required) {
+                        acc.push(curr[0]);
                     }
-                    acc.push(curr);
                     return acc;
-                }, []);
-                if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
-                    continue;
                 }
-                values = values.filter((val) => {
+                let current = 0;
+                const props = this.config.properties[curr[0]];
+                const declaration = this.declarations.get(curr[0]);
+                // @ts-ignore
+                for (const val of (declaration instanceof PropertySet ? [...declaration][0] : declaration).val) {
+                    if (separator != null && separator.typ == val.typ && eq(separator, val)) {
+                        current++;
+                        if (tokens[curr[0]].length == current) {
+                            tokens[curr[0]].push([]);
+                        }
+                        continue;
+                    }
                     if (val.typ == 'Whitespace' || val.typ == 'Comment') {
-                        return false;
+                        continue;
                     }
-                    return !(val.typ == 'Iden' && props.default.includes(val.val));
-                });
-                if (values.length > 0) {
-                    if ('mapping' in props) {
-                        // @ts-ignore
-                        if (!('constraints' in props) || !('max' in props.constraints) || values.length <= props.constraints.mapping.max) {
-                            let i = values.length;
-                            while (i--) {
+                    if (props.multiple && props.separator != null && props.separator.typ == val.typ && eq(props.separator, val)) {
+                        continue;
+                    }
+                    if (matchType(val, curr[1])) {
+                        if (!(curr[0] in tokens)) {
+                            tokens[curr[0]] = [[]];
+                        }
+                        // is default value
+                        tokens[curr[0]][current].push(val);
+                        // continue;
+                    }
+                    else {
+                        acc.push(curr[0]);
+                        break;
+                    }
+                }
+                if (count == 0) {
+                    count = current;
+                }
+                return acc;
+            }, []);
+            count++;
+            if (!Object.values(tokens).every(v => v.length == count)) {
+                // @ts-ignore
+                iterable = this.declarations.values();
+            }
+            else {
+                const values = Object.entries(tokens).reduce((acc, curr) => {
+                    const props = this.config.properties[curr[0]];
+                    for (let i = 0; i < curr[1].length; i++) {
+                        if (acc.length == i) {
+                            acc.push([]);
+                        }
+                        let values = curr[1][i].reduce((acc, curr) => {
+                            if (acc.length > 0) {
+                                acc.push({ typ: 'Whitespace' });
+                            }
+                            acc.push(curr);
+                            return acc;
+                        }, []);
+                        // @todo remove renderToken call
+                        if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
+                            continue;
+                        }
+                        let doFilterDefault = true;
+                        if (curr[0] in propertiesConfig.properties) {
+                            for (let v of values) {
+                                if (!['Whitespace', 'Comment', 'Iden'].includes(v.typ)
+                                    || (v.typ == 'Iden' && !this.config.properties[curr[0]].default.includes(v.val))) {
+                                    doFilterDefault = false;
+                                    break;
+                                }
+                            }
+                        }
+                        // remove default values
+                        values = values.filter((val) => {
+                            if (val.typ == 'Whitespace' || val.typ == 'Comment') {
+                                return false;
+                            }
+                            return !doFilterDefault || !(val.typ == 'Iden' && props.default.includes(val.val));
+                        });
+                        if (values.length > 0) {
+                            if ('mapping' in props) {
                                 // @ts-ignore
-                                if (values[i].typ == 'Iden' && values[i].val in props.mapping) {
-                                    // @ts-ignore
-                                    values.splice(i, 1, ...parseString(props.mapping[values[i].val]));
+                                if (!('constraints' in props) || !('max' in props.constraints) || values.length <= props.constraints.mapping.max) {
+                                    let i = values.length;
+                                    while (i--) {
+                                        // @ts-ignore
+                                        if (values[i].typ == 'Iden' && values[i].val in props.mapping) {
+                                            // @ts-ignore
+                                            values.splice(i, 1, ...parseString(props.mapping[values[i].val]));
+                                        }
+                                    }
                                 }
                             }
+                            if ('prefix' in props) {
+                                // @ts-ignore
+                                acc[i].push({ ...props.prefix });
+                            }
+                            else if (acc[i].length > 0) {
+                                acc[i].push({ typ: 'Whitespace' });
+                            }
+                            acc[i].push(...values.reduce((acc, curr) => {
+                                if (acc.length > 0) {
+                                    // @ts-ignore
+                                    acc.push({ ...(props.separator ?? { typ: 'Whitespace' }) });
+                                }
+                                // @ts-ignore
+                                acc.push(curr);
+                                return acc;
+                            }, []));
                         }
                     }
-                    if ('prefix' in props) {
-                        // @ts-ignore
-                        acc[i].push({ ...props.prefix });
+                    return acc;
+                }, []).reduce((acc, curr) => {
+                    if (acc.length > 0) {
+                        acc.push({ ...separator });
                     }
-                    else if (acc[i].length > 0) {
-                        acc[i].push({ typ: 'Whitespace' });
+                    if (curr.length == 0 && this.config.default.length > 0) {
+                        curr.push(...parseString(this.config.default[0]).reduce((acc, curr) => {
+                            if (acc.length > 0) {
+                                acc.push({ typ: 'Whitespace' });
+                            }
+                            acc.push(curr);
+                            return acc;
+                        }, []));
                     }
-                    acc[i].push(...values.reduce((acc, curr) => {
-                        if (acc.length > 0) {
+                    acc.push(...curr);
+                    return acc;
+                }, []);
+                iterable = [{
+                        typ: 'Declaration',
+                        nam: this.config.shorthand,
+                        val: values
+                    }][Symbol.iterator]();
+            }
+        }
+        const iterators = [];
+        return {
+            // @ts-ignore
+            next() {
+                let v = iterable.next();
+                while (v.done || v.value instanceof PropertySet) {
+                    if (v.value instanceof PropertySet) {
+                        // @ts-ignore
+                        iterators.push(iterable);
+                        iterable = v.value[Symbol.iterator]();
+                        v = iterable.next();
+                    }
+                    if (v.done) {
+                        if (iterators.length > 0) {
                             // @ts-ignore
-                            acc.push({ ...(props.separator ?? { typ: 'Whitespace' }) });
+                            iterable = iterators.pop();
+                            v = iterable.next();
+                        }
+                        if (v.done && iterators.length == 0) {
+                            break;
                         }
-                        // @ts-ignore
-                        acc.push(curr);
-                        return acc;
-                    }, []));
-                }
-            }
-            return acc;
-        }, []).reduce((acc, curr) => {
-            if (acc.length > 0) {
-                acc.push({ ...separator });
-            }
-            if (curr.length == 0) {
-                curr.push(...this.config.default[0].split(/\s/).map(getTokenType).reduce((acc, curr) => {
-                    if (acc.length > 0) {
-                        acc.push({ typ: 'Whitespace' });
                     }
-                    acc.push(curr);
-                    return acc;
-                }, []));
+                }
+                return v;
             }
-            acc.push(...curr);
-            return acc;
-        }, []);
-        return [{
-                typ: 'Declaration',
-                nam: this.config.shorthand,
-                val: values
-            }][Symbol.iterator]();
+        };
     }
 }
 

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

@@ -10,8 +10,7 @@ class PropertySet {
     }
     add(declaration) {
         if (declaration.nam == this.config.shorthand) {
-            this.declarations.clear();
-            this.declarations.set(declaration.nam, declaration);
+            this.declarations = new Map;
         }
         else {
             // expand shorthand
@@ -34,6 +33,10 @@ class PropertySet {
                     }
                     if (token.typ != 'Whitespace' && token.typ != 'Comment') {
                         if (token.typ == 'Iden' && this.config.keywords.includes(token.val)) {
+                            if (tokens.length == 0) {
+                                tokens.push([]);
+                                current++;
+                            }
                             tokens[current].push(token);
                         }
                         if (token.typ == 'Literal' && token.val == this.config.separator) {
@@ -49,10 +52,6 @@ class PropertySet {
                     this.declarations.delete(this.config.shorthand);
                     for (const values of tokens) {
                         this.config.properties.forEach((property, index) => {
-                            // if (property == declaration.nam) {
-                            //
-                            //     return;
-                            // }
                             if (!this.declarations.has(property)) {
                                 this.declarations.set(property, {
                                     typ: 'Declaration',
@@ -81,30 +80,20 @@ class PropertySet {
                 this.declarations.set(declaration.nam, declaration);
                 return this;
             }
-            // declaration.chi = declaration.chi.reduce((acc: Token[], token: Token) => {
-            //
-            //     if (this.config.types.includes(token.typ) || ('0' == (<DimensionToken>token).chi && (
-            //         this.config.types.includes('Length') ||
-            //         this.config.types.includes('Angle') ||
-            //     this.config.types.includes('Dimension'))) || (token.typ == 'Iden' && this.config.keywords.includes(token.chi))) {
-            //
-            //         acc.push(token);
-            //     }
-            //
-            //     return acc;
-            // }, <Token[]>[]);
-            this.declarations.set(declaration.nam, declaration);
         }
+        this.declarations.set(declaration.nam, declaration);
         return this;
     }
+    isShortHand() {
+        if (this.declarations.has(this.config.shorthand)) {
+            return this.declarations.size == 1;
+        }
+        return this.config.properties.length == this.declarations.size;
+    }
     [Symbol.iterator]() {
         let iterator;
         const declarations = this.declarations;
-        if (declarations.size < this.config.properties.length || this.config.properties.some((property, index) => {
-            return !declarations.has(property) || (index > 0 &&
-                // @ts-ignore
-                declarations.get(property).val.length != declarations.get(this.config.properties[Math.floor(index / 2)]).val.length);
-        })) {
+        if (declarations.size < this.config.properties.length) {
             iterator = declarations.values();
         }
         else {
@@ -162,17 +151,20 @@ class PropertySet {
                         return acc;
                     }, [])
                 }][Symbol.iterator]();
-            return {
-                next() {
-                    return iterator.next();
-                }
-            };
+            // return {
+            //     next() {
+            //
+            //         return iterator.next();
+            //     }
+            // }
         }
-        return {
-            next() {
-                return iterator.next();
-            }
-        };
+        return iterator;
+        // return {
+        //     next() {
+        //
+        //         return iterator.next();
+        //     }
+        // }
     }
 }