nuxt-ignis 0.5.1 → 0.5.3

package/.output/server/node_modules/csso/lib/restructure/6-restructBlock.js

@@ -0,0 +1,308 @@
+import {
+    walk,
+    generate,
+    property as resolveProperty,
+    keyword as resolveKeyword
+} from 'css-tree';
+
+let fingerprintId = 1;
+const dontRestructure = new Set([
+    'src' // https://github.com/afelix/csso/issues/50
+]);
+
+const DONT_MIX_VALUE = {
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/display#Browser_compatibility
+    'display': /table|ruby|flex|-(flex)?box$|grid|contents|run-in/i,
+    // https://developer.mozilla.org/en/docs/Web/CSS/text-align
+    'text-align': /^(start|end|match-parent|justify-all)$/i
+};
+
+const SAFE_VALUES = {
+    cursor: [
+        'auto', 'crosshair', 'default', 'move', 'text', 'wait', 'help',
+        'n-resize', 'e-resize', 's-resize', 'w-resize',
+        'ne-resize', 'nw-resize', 'se-resize', 'sw-resize',
+        'pointer', 'progress', 'not-allowed', 'no-drop', 'vertical-text', 'all-scroll',
+        'col-resize', 'row-resize'
+    ],
+    overflow: [
+        'hidden', 'visible', 'scroll', 'auto'
+    ],
+    position: [
+        'static', 'relative', 'absolute', 'fixed'
+    ]
+};
+
+const NEEDLESS_TABLE = {
+    'border-width': ['border'],
+    'border-style': ['border'],
+    'border-color': ['border'],
+    'border-top': ['border'],
+    'border-right': ['border'],
+    'border-bottom': ['border'],
+    'border-left': ['border'],
+    'border-top-width': ['border-top', 'border-width', 'border'],
+    'border-right-width': ['border-right', 'border-width', 'border'],
+    'border-bottom-width': ['border-bottom', 'border-width', 'border'],
+    'border-left-width': ['border-left', 'border-width', 'border'],
+    'border-top-style': ['border-top', 'border-style', 'border'],
+    'border-right-style': ['border-right', 'border-style', 'border'],
+    'border-bottom-style': ['border-bottom', 'border-style', 'border'],
+    'border-left-style': ['border-left', 'border-style', 'border'],
+    'border-top-color': ['border-top', 'border-color', 'border'],
+    'border-right-color': ['border-right', 'border-color', 'border'],
+    'border-bottom-color': ['border-bottom', 'border-color', 'border'],
+    'border-left-color': ['border-left', 'border-color', 'border'],
+    'margin-top': ['margin'],
+    'margin-right': ['margin'],
+    'margin-bottom': ['margin'],
+    'margin-left': ['margin'],
+    'padding-top': ['padding'],
+    'padding-right': ['padding'],
+    'padding-bottom': ['padding'],
+    'padding-left': ['padding'],
+    'font-style': ['font'],
+    'font-variant': ['font'],
+    'font-weight': ['font'],
+    'font-size': ['font'],
+    'font-family': ['font'],
+    'list-style-type': ['list-style'],
+    'list-style-position': ['list-style'],
+    'list-style-image': ['list-style']
+};
+
+function getPropertyFingerprint(propertyName, declaration, fingerprints) {
+    const realName = resolveProperty(propertyName).basename;
+
+    if (realName === 'background') {
+        return propertyName + ':' + generate(declaration.value);
+    }
+
+    const declarationId = declaration.id;
+    let fingerprint = fingerprints[declarationId];
+
+    if (!fingerprint) {
+        switch (declaration.value.type) {
+            case 'Value':
+                const special = {};
+                let vendorId = '';
+                let iehack = '';
+                let raw = false;
+
+                declaration.value.children.forEach(function walk(node) {
+                    switch (node.type) {
+                        case 'Value':
+                        case 'Brackets':
+                        case 'Parentheses':
+                            node.children.forEach(walk);
+                            break;
+
+                        case 'Raw':
+                            raw = true;
+                            break;
+
+                        case 'Identifier': {
+                            const { name } = node;
+
+                            if (!vendorId) {
+                                vendorId = resolveKeyword(name).vendor;
+                            }
+
+                            if (/\\[09]/.test(name)) {
+                                iehack = RegExp.lastMatch;
+                            }
+
+                            if (SAFE_VALUES.hasOwnProperty(realName)) {
+                                if (SAFE_VALUES[realName].indexOf(name) === -1) {
+                                    special[name] = true;
+                                }
+                            } else if (DONT_MIX_VALUE.hasOwnProperty(realName)) {
+                                if (DONT_MIX_VALUE[realName].test(name)) {
+                                    special[name] = true;
+                                }
+                            }
+
+                            break;
+                        }
+
+                        case 'Function': {
+                            let { name } = node;
+
+                            if (!vendorId) {
+                                vendorId = resolveKeyword(name).vendor;
+                            }
+
+                            if (name === 'rect') {
+                                // there are 2 forms of rect:
+                                //   rect(<top>, <right>, <bottom>, <left>) - standart
+                                //   rect(<top> <right> <bottom> <left>) – backwards compatible syntax
+                                // only the same form values can be merged
+                                const hasComma = node.children.some((node) =>
+                                    node.type === 'Operator' && node.value === ','
+                                );
+
+                                if (!hasComma) {
+                                    name = 'rect-backward';
+                                }
+                            }
+
+                            special[name + '()'] = true;
+
+                            // check nested tokens too
+                            node.children.forEach(walk);
+
+                            break;
+                        }
+
+                        case 'Dimension': {
+                            const { unit } = node;
+
+                            if (/\\[09]/.test(unit)) {
+                                iehack = RegExp.lastMatch;
+                            }
+
+                            switch (unit) {
+                                // is not supported until IE11
+                                case 'rem':
+
+                                // v* units is too buggy across browsers and better
+                                // don't merge values with those units
+                                case 'vw':
+                                case 'vh':
+                                case 'vmin':
+                                case 'vmax':
+                                case 'vm': // IE9 supporting "vm" instead of "vmin".
+                                    special[unit] = true;
+                                    break;
+                            }
+
+                            break;
+                        }
+                    }
+                });
+
+                fingerprint = raw
+                    ? '!' + fingerprintId++
+                    : '!' + Object.keys(special).sort() + '|' + iehack + vendorId;
+                break;
+
+            case 'Raw':
+                fingerprint = '!' + declaration.value.value;
+                break;
+
+            default:
+                fingerprint = generate(declaration.value);
+        }
+
+        fingerprints[declarationId] = fingerprint;
+    }
+
+    return propertyName + fingerprint;
+}
+
+function needless(props, declaration, fingerprints) {
+    const property = resolveProperty(declaration.property);
+
+    if (NEEDLESS_TABLE.hasOwnProperty(property.basename)) {
+        const table = NEEDLESS_TABLE[property.basename];
+
+        for (const entry of table) {
+            const ppre = getPropertyFingerprint(property.prefix + entry, declaration, fingerprints);
+            const prev = props.hasOwnProperty(ppre) ? props[ppre] : null;
+
+            if (prev && (!declaration.important || prev.item.data.important)) {
+                return prev;
+            }
+        }
+    }
+}
+
+function processRule(rule, item, list, props, fingerprints) {
+    const declarations = rule.block.children;
+
+    declarations.forEachRight(function(declaration, declarationItem) {
+        const { property } = declaration;
+        const fingerprint = getPropertyFingerprint(property, declaration, fingerprints);
+        const prev = props[fingerprint];
+
+        if (prev && !dontRestructure.has(property)) {
+            if (declaration.important && !prev.item.data.important) {
+                props[fingerprint] = {
+                    block: declarations,
+                    item: declarationItem
+                };
+
+                prev.block.remove(prev.item);
+
+                // TODO: use it when we can refer to several points in source
+                // declaration.loc = {
+                //     primary: declaration.loc,
+                //     merged: prev.item.data.loc
+                // };
+            } else {
+                declarations.remove(declarationItem);
+
+                // TODO: use it when we can refer to several points in source
+                // prev.item.data.loc = {
+                //     primary: prev.item.data.loc,
+                //     merged: declaration.loc
+                // };
+            }
+        } else {
+            const prev = needless(props, declaration, fingerprints);
+
+            if (prev) {
+                declarations.remove(declarationItem);
+
+                // TODO: use it when we can refer to several points in source
+                // prev.item.data.loc = {
+                //     primary: prev.item.data.loc,
+                //     merged: declaration.loc
+                // };
+            } else {
+                declaration.fingerprint = fingerprint;
+
+                props[fingerprint] = {
+                    block: declarations,
+                    item: declarationItem
+                };
+            }
+        }
+    });
+
+    if (declarations.isEmpty) {
+        list.remove(item);
+    }
+}
+
+export default function restructBlock(ast) {
+    const stylesheetMap = {};
+    const fingerprints = Object.create(null);
+
+    walk(ast, {
+        visit: 'Rule',
+        reverse: true,
+        enter(node, item, list) {
+            const stylesheet = this.block || this.stylesheet;
+            const ruleId = (node.pseudoSignature || '') + '|' + node.prelude.children.first.id;
+            let ruleMap;
+            let props;
+
+            if (!stylesheetMap.hasOwnProperty(stylesheet.id)) {
+                ruleMap = {};
+                stylesheetMap[stylesheet.id] = ruleMap;
+            } else {
+                ruleMap = stylesheetMap[stylesheet.id];
+            }
+
+            if (ruleMap.hasOwnProperty(ruleId)) {
+                props = ruleMap[ruleId];
+            } else {
+                props = {};
+                ruleMap[ruleId] = props;
+            }
+
+            processRule.call(this, node, item, list, props, fingerprints);
+        }
+    });
+};

package/.output/server/node_modules/csso/lib/restructure/7-mergeRuleset.js

@@ -0,0 +1,86 @@
+import { walk } from 'css-tree';
+import { unsafeToSkipNode, isEqualDeclarations} from './utils.js';
+
+/*
+    At this step all rules has single simple selector. We try to join by equal
+    declaration blocks to first rule, e.g.
+
+    .a { color: red }
+    b { ... }
+    .b { color: red }
+    ->
+    .a, .b { color: red }
+    b { ... }
+*/
+
+function processRule(node, item, list) {
+    const selectors = node.prelude.children;
+    const declarations = node.block.children;
+    const nodeCompareMarker = selectors.first.compareMarker;
+    const skippedCompareMarkers = {};
+
+    list.nextUntil(item.next, function(next, nextItem) {
+        // skip non-ruleset node if safe
+        if (next.type !== 'Rule') {
+            return unsafeToSkipNode.call(selectors, next);
+        }
+
+        if (node.pseudoSignature !== next.pseudoSignature) {
+            return true;
+        }
+
+        const nextFirstSelector = next.prelude.children.head;
+        const nextDeclarations = next.block.children;
+        const nextCompareMarker = nextFirstSelector.data.compareMarker;
+
+        // if next ruleset has same marked as one of skipped then stop joining
+        if (nextCompareMarker in skippedCompareMarkers) {
+            return true;
+        }
+
+        // try to join by selectors
+        if (selectors.head === selectors.tail) {
+            if (selectors.first.id === nextFirstSelector.data.id) {
+                declarations.appendList(nextDeclarations);
+                list.remove(nextItem);
+                return;
+            }
+        }
+
+        // try to join by properties
+        if (isEqualDeclarations(declarations, nextDeclarations)) {
+            const nextStr = nextFirstSelector.data.id;
+
+            selectors.some((data, item) => {
+                const curStr = data.id;
+
+                if (nextStr < curStr) {
+                    selectors.insert(nextFirstSelector, item);
+                    return true;
+                }
+
+                if (!item.next) {
+                    selectors.insert(nextFirstSelector);
+                    return true;
+                }
+            });
+
+            list.remove(nextItem);
+            return;
+        }
+
+        // go to next ruleset if current one can be skipped (has no equal specificity nor element selector)
+        if (nextCompareMarker === nodeCompareMarker) {
+            return true;
+        }
+
+        skippedCompareMarkers[nextCompareMarker] = true;
+    });
+}
+
+export default function mergeRule(ast) {
+    walk(ast, {
+        visit: 'Rule',
+        enter: processRule
+    });
+};

package/.output/server/node_modules/csso/lib/restructure/8-restructRuleset.js

@@ -0,0 +1,176 @@
+import { List, walk } from 'css-tree';
+import {
+    unsafeToSkipNode,
+    isEqualSelectors,
+    compareDeclarations,
+    addSelectors
+} from './utils.js';
+
+function calcSelectorLength(list) {
+    return list.reduce((res, data) => res + data.id.length + 1, 0) - 1;
+}
+
+function calcDeclarationsLength(tokens) {
+    let length = 0;
+
+    for (const token of tokens) {
+        length += token.length;
+    }
+
+    return (
+        length +          // declarations
+        tokens.length - 1 // delimeters
+    );
+}
+
+function processRule(node, item, list) {
+    const avoidRulesMerge = this.block !== null ? this.block.avoidRulesMerge : false;
+    const selectors = node.prelude.children;
+    const block = node.block;
+    const disallowDownMarkers = Object.create(null);
+    let allowMergeUp = true;
+    let allowMergeDown = true;
+
+    list.prevUntil(item.prev, function(prev, prevItem) {
+        const prevBlock = prev.block;
+        const prevType = prev.type;
+
+        if (prevType !== 'Rule') {
+            const unsafe = unsafeToSkipNode.call(selectors, prev);
+
+            if (!unsafe && prevType === 'Atrule' && prevBlock) {
+                walk(prevBlock, {
+                    visit: 'Rule',
+                    enter(node) {
+                        node.prelude.children.forEach((data) => {
+                            disallowDownMarkers[data.compareMarker] = true;
+                        });
+                    }
+                });
+            }
+
+            return unsafe;
+        }
+
+        if (node.pseudoSignature !== prev.pseudoSignature) {
+            return true;
+        }
+
+        const prevSelectors = prev.prelude.children;
+
+        allowMergeDown = !prevSelectors.some((selector) =>
+            selector.compareMarker in disallowDownMarkers
+        );
+
+        // try prev ruleset if simpleselectors has no equal specifity and element selector
+        if (!allowMergeDown && !allowMergeUp) {
+            return true;
+        }
+
+        // try to join by selectors
+        if (allowMergeUp && isEqualSelectors(prevSelectors, selectors)) {
+            prevBlock.children.appendList(block.children);
+            list.remove(item);
+
+            return true;
+        }
+
+        // try to join by properties
+        const diff = compareDeclarations(block.children, prevBlock.children);
+
+        // console.log(diff.eq, diff.ne1, diff.ne2);
+
+        if (diff.eq.length) {
+            if (!diff.ne1.length && !diff.ne2.length) {
+                // equal blocks
+                if (allowMergeDown) {
+                    addSelectors(selectors, prevSelectors);
+                    list.remove(prevItem);
+                }
+
+                return true;
+            } else if (!avoidRulesMerge) { /* probably we don't need to prevent those merges for @keyframes
+                                              TODO: need to be checked */
+
+                if (diff.ne1.length && !diff.ne2.length) {
+                    // prevBlock is subset block
+                    const selectorLength = calcSelectorLength(selectors);
+                    const blockLength = calcDeclarationsLength(diff.eq); // declarations length
+
+                    if (allowMergeUp && selectorLength < blockLength) {
+                        addSelectors(prevSelectors, selectors);
+                        block.children.fromArray(diff.ne1);
+                    }
+                } else if (!diff.ne1.length && diff.ne2.length) {
+                    // node is subset of prevBlock
+                    const selectorLength = calcSelectorLength(prevSelectors);
+                    const blockLength = calcDeclarationsLength(diff.eq); // declarations length
+
+                    if (allowMergeDown && selectorLength < blockLength) {
+                        addSelectors(selectors, prevSelectors);
+                        prevBlock.children.fromArray(diff.ne2);
+                    }
+                } else {
+                    // diff.ne1.length && diff.ne2.length
+                    // extract equal block
+                    const newSelector = {
+                        type: 'SelectorList',
+                        loc: null,
+                        children: addSelectors(prevSelectors.copy(), selectors)
+                    };
+                    const newBlockLength = calcSelectorLength(newSelector.children) + 2; // selectors length + curly braces length
+                    const blockLength = calcDeclarationsLength(diff.eq); // declarations length
+
+                    // create new ruleset if declarations length greater than
+                    // ruleset description overhead
+                    if (blockLength >= newBlockLength) {
+                        const newItem = list.createItem({
+                            type: 'Rule',
+                            loc: null,
+                            prelude: newSelector,
+                            block: {
+                                type: 'Block',
+                                loc: null,
+                                children: new List().fromArray(diff.eq)
+                            },
+                            pseudoSignature: node.pseudoSignature
+                        });
+
+                        block.children.fromArray(diff.ne1);
+                        prevBlock.children.fromArray(diff.ne2overrided);
+
+                        if (allowMergeUp) {
+                            list.insert(newItem, prevItem);
+                        } else {
+                            list.insert(newItem, item);
+                        }
+
+                        return true;
+                    }
+                }
+            }
+        }
+
+        if (allowMergeUp) {
+            // TODO: disallow up merge only if any property interception only (i.e. diff.ne2overrided.length > 0);
+            // await property families to find property interception correctly
+            allowMergeUp = !prevSelectors.some((prevSelector) =>
+                selectors.some((selector) =>
+                    selector.compareMarker === prevSelector.compareMarker
+                )
+            );
+        }
+
+        prevSelectors.forEach((data) => {
+            disallowDownMarkers[data.compareMarker] = true;
+        });
+    });
+}
+
+export default function restructRule(ast) {
+    walk(ast, {
+        visit: 'Rule',
+        reverse: true,
+        enter: processRule
+    });
+};

package/.output/server/node_modules/csso/lib/restructure/index.js

@@ -0,0 +1,35 @@
+import prepare from './prepare/index.js';
+import mergeAtrule from './1-mergeAtrule.js';
+import initialMergeRuleset from './2-initialMergeRuleset.js';
+import disjoinRuleset from './3-disjoinRuleset.js';
+import restructShorthand from './4-restructShorthand.js';
+import restructBlock from './6-restructBlock.js';
+import mergeRuleset from './7-mergeRuleset.js';
+import restructRuleset from './8-restructRuleset.js';
+
+export default function(ast, options) {
+    // prepare ast for restructing
+    const indexer = prepare(ast, options);
+    options.logger('prepare', ast);
+
+    mergeAtrule(ast, options);
+    options.logger('mergeAtrule', ast);
+
+    initialMergeRuleset(ast);
+    options.logger('initialMergeRuleset', ast);
+
+    disjoinRuleset(ast);
+    options.logger('disjoinRuleset', ast);
+
+    restructShorthand(ast, indexer);
+    options.logger('restructShorthand', ast);
+
+    restructBlock(ast);
+    options.logger('restructBlock', ast);
+
+    mergeRuleset(ast);
+    options.logger('mergeRuleset', ast);
+
+    restructRuleset(ast);
+    options.logger('restructRuleset', ast);
+};

package/.output/server/node_modules/csso/lib/restructure/prepare/createDeclarationIndexer.js

@@ -0,0 +1,31 @@
+import { generate } from 'css-tree';
+
+class Index {
+    constructor() {
+        this.map = new Map();
+    }
+    resolve(str) {
+        let index = this.map.get(str);
+
+        if (index === undefined) {
+            index = this.map.size + 1;
+            this.map.set(str, index);
+        }
+
+        return index;
+    }
+};
+
+export default function createDeclarationIndexer() {
+    const ids = new Index();
+
+    return function markDeclaration(node) {
+        const id = generate(node);
+
+        node.id = ids.resolve(id);
+        node.length = id.length;
+        node.fingerprint = null;
+
+        return node;
+    };
+};

package/.output/server/node_modules/csso/lib/restructure/prepare/index.js

@@ -0,0 +1,41 @@
+import { walk, generate, keyword as resolveKeyword } from 'css-tree';
+import createDeclarationIndexer from './createDeclarationIndexer.js';
+import processSelector from './processSelector.js';
+
+export default function prepare(ast, options) {
+    const markDeclaration = createDeclarationIndexer();
+
+    walk(ast, {
+        visit: 'Rule',
+        enter(node) {
+            node.block.children.forEach(markDeclaration);
+            processSelector(node, options.usage);
+        }
+    });
+
+    walk(ast, {
+        visit: 'Atrule',
+        enter(node) {
+            if (node.prelude) {
+                node.prelude.id = null; // pre-init property to avoid multiple hidden class for generate
+                node.prelude.id = generate(node.prelude);
+            }
+
+            // compare keyframe selectors by its values
+            // NOTE: still no clarification about problems with keyframes selector grouping (issue #197)
+            if (resolveKeyword(node.name).basename === 'keyframes') {
+                node.block.avoidRulesMerge = true;  /* probably we don't need to prevent those merges for @keyframes
+                                                       TODO: need to be checked */
+                node.block.children.forEach(function(rule) {
+                    rule.prelude.children.forEach(function(simpleselector) {
+                        simpleselector.compareMarker = simpleselector.id;
+                    });
+                });
+            }
+        }
+    });
+
+    return {
+        declaration: markDeclaration
+    };
+};