@eslint/css-tree 3.2.0

package/lib/walker/create.js

@@ -0,0 +1,287 @@
+const { hasOwnProperty } = Object.prototype;
+const noop = function() {};
+
+function ensureFunction(value) {
+    return typeof value === 'function' ? value : noop;
+}
+
+function invokeForType(fn, type) {
+    return function(node, item, list) {
+        if (node.type === type) {
+            fn.call(this, node, item, list);
+        }
+    };
+}
+
+function getWalkersFromStructure(name, nodeType) {
+    const structure = nodeType.structure;
+    const walkers = [];
+
+    for (const key in structure) {
+        if (hasOwnProperty.call(structure, key) === false) {
+            continue;
+        }
+
+        let fieldTypes = structure[key];
+        const walker = {
+            name: key,
+            type: false,
+            nullable: false
+        };
+
+        if (!Array.isArray(fieldTypes)) {
+            fieldTypes = [fieldTypes];
+        }
+
+        for (const fieldType of fieldTypes) {
+            if (fieldType === null) {
+                walker.nullable = true;
+            } else if (typeof fieldType === 'string') {
+                walker.type = 'node';
+            } else if (Array.isArray(fieldType)) {
+                walker.type = 'list';
+            }
+        }
+
+        if (walker.type) {
+            walkers.push(walker);
+        }
+    }
+
+    if (walkers.length) {
+        return {
+            context: nodeType.walkContext,
+            fields: walkers
+        };
+    }
+
+    return null;
+}
+
+function getTypesFromConfig(config) {
+    const types = {};
+
+    for (const name in config.node) {
+        if (hasOwnProperty.call(config.node, name)) {
+            const nodeType = config.node[name];
+
+            if (!nodeType.structure) {
+                throw new Error('Missed `structure` field in `' + name + '` node type definition');
+            }
+
+            types[name] = getWalkersFromStructure(name, nodeType);
+        }
+    }
+
+    return types;
+}
+
+function createTypeIterator(config, reverse) {
+    const fields = config.fields.slice();
+    const contextName = config.context;
+    const useContext = typeof contextName === 'string';
+
+    if (reverse) {
+        fields.reverse();
+    }
+
+    return function(node, context, walk, walkReducer) {
+        let prevContextValue;
+
+        if (useContext) {
+            prevContextValue = context[contextName];
+            context[contextName] = node;
+        }
+
+        for (const field of fields) {
+            const ref = node[field.name];
+
+            if (!field.nullable || ref) {
+                if (field.type === 'list') {
+                    const breakWalk = reverse
+                        ? ref.reduceRight(walkReducer, false)
+                        : ref.reduce(walkReducer, false);
+
+                    if (breakWalk) {
+                        return true;
+                    }
+                } else if (walk(ref)) {
+                    return true;
+                }
+            }
+        }
+
+        if (useContext) {
+            context[contextName] = prevContextValue;
+        }
+    };
+}
+
+function createFastTraveralMap({
+    StyleSheet,
+    Atrule,
+    Rule,
+    Block,
+    DeclarationList
+}) {
+    return {
+        Atrule: {
+            StyleSheet,
+            Atrule,
+            Rule,
+            Block
+        },
+        Rule: {
+            StyleSheet,
+            Atrule,
+            Rule,
+            Block
+        },
+        Declaration: {
+            StyleSheet,
+            Atrule,
+            Rule,
+            Block,
+            DeclarationList
+        }
+    };
+}
+
+export function createWalker(config) {
+    const types = getTypesFromConfig(config);
+    const iteratorsNatural = {};
+    const iteratorsReverse = {};
+    const breakWalk = Symbol('break-walk');
+    const skipNode = Symbol('skip-node');
+
+    for (const name in types) {
+        if (hasOwnProperty.call(types, name) && types[name] !== null) {
+            iteratorsNatural[name] = createTypeIterator(types[name], false);
+            iteratorsReverse[name] = createTypeIterator(types[name], true);
+        }
+    }
+
+    const fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural);
+    const fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse);
+
+    const walk = function(root, options) {
+        function walkNode(node, item, list) {
+            const enterRet = enter.call(context, node, item, list);
+
+            if (enterRet === breakWalk) {
+                return true;
+            }
+
+            if (enterRet === skipNode) {
+                return false;
+            }
+
+            if (iterators.hasOwnProperty(node.type)) {
+                if (iterators[node.type](node, context, walkNode, walkReducer)) {
+                    return true;
+                }
+            }
+
+            if (leave.call(context, node, item, list) === breakWalk) {
+                return true;
+            }
+
+            return false;
+        }
+
+        let enter = noop;
+        let leave = noop;
+        let iterators = iteratorsNatural;
+        let walkReducer = (ret, data, item, list) => ret || walkNode(data, item, list);
+        const context = {
+            break: breakWalk,
+            skip: skipNode,
+
+            root,
+            stylesheet: null,
+            atrule: null,
+            atrulePrelude: null,
+            rule: null,
+            selector: null,
+            block: null,
+            declaration: null,
+            function: null
+        };
+
+        if (typeof options === 'function') {
+            enter = options;
+        } else if (options) {
+            enter = ensureFunction(options.enter);
+            leave = ensureFunction(options.leave);
+
+            if (options.reverse) {
+                iterators = iteratorsReverse;
+            }
+
+            if (options.visit) {
+                if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) {
+                    iterators = options.reverse
+                        ? fastTraversalIteratorsReverse[options.visit]
+                        : fastTraversalIteratorsNatural[options.visit];
+                } else if (!types.hasOwnProperty(options.visit)) {
+                    throw new Error('Bad value `' + options.visit + '` for `visit` option (should be: ' + Object.keys(types).sort().join(', ') + ')');
+                }
+
+                enter = invokeForType(enter, options.visit);
+                leave = invokeForType(leave, options.visit);
+            }
+        }
+
+        if (enter === noop && leave === noop) {
+            throw new Error('Neither `enter` nor `leave` walker handler is set or both aren\'t a function');
+        }
+
+        walkNode(root);
+    };
+
+    walk.break = breakWalk;
+    walk.skip = skipNode;
+
+    walk.find = function(ast, fn) {
+        let found = null;
+
+        walk(ast, function(node, item, list) {
+            if (fn.call(this, node, item, list)) {
+                found = node;
+                return breakWalk;
+            }
+        });
+
+        return found;
+    };
+
+    walk.findLast = function(ast, fn) {
+        let found = null;
+
+        walk(ast, {
+            reverse: true,
+            enter(node, item, list) {
+                if (fn.call(this, node, item, list)) {
+                    found = node;
+                    return breakWalk;
+                }
+            }
+        });
+
+        return found;
+    };
+
+    walk.findAll = function(ast, fn) {
+        const found = [];
+
+        walk(ast, function(node, item, list) {
+            if (fn.call(this, node, item, list)) {
+                found.push(node);
+            }
+        });
+
+        return found;
+    };
+
+    return walk;
+};

package/lib/walker/index.js

@@ -0,0 +1,4 @@
+import { createWalker } from './create.js';
+import config from '../syntax/config/walker.js';
+
+export default createWalker(config);

package/package.json

@@ -0,0 +1,133 @@
+{
+  "name": "@eslint/css-tree",
+  "version": "3.2.0",
+  "description": "A tool set for CSS: fast detailed parser (CSS → AST), walker (AST traversal), generator (AST → CSS) and lexer (validation and matching) based on specs and browser implementations",
+  "author": "Roman Dvornov <rdvornov@gmail.com> (https://github.com/lahmatiy)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": "eslint/csstree",
+  "keywords": [
+    "css",
+    "ast",
+    "tokenizer",
+    "parser",
+    "walker",
+    "lexer",
+    "generator",
+    "utils",
+    "syntax",
+    "validation"
+  ],
+  "type": "module",
+  "module": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "sideEffects": false,
+  "main": "./cjs/index.cjs",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "require": "./cjs/index.cjs",
+      "types": "./lib/index.d.ts"
+    },
+    "./dist/*": "./dist/*.js",
+    "./package.json": "./package.json",
+    "./tokenizer": {
+      "import": "./lib/tokenizer/index.js",
+      "require": "./cjs/tokenizer/index.cjs"
+    },
+    "./parser": {
+      "import": "./lib/parser/index.js",
+      "require": "./cjs/parser/index.cjs"
+    },
+    "./selector-parser": {
+      "import": "./lib/parser/parse-selector.js",
+      "require": "./cjs/parser/parse-selector.cjs"
+    },
+    "./generator": {
+      "import": "./lib/generator/index.js",
+      "require": "./cjs/generator/index.cjs"
+    },
+    "./walker": {
+      "import": "./lib/walker/index.js",
+      "require": "./cjs/walker/index.cjs"
+    },
+    "./convertor": {
+      "import": "./lib/convertor/index.js",
+      "require": "./cjs/convertor/index.cjs"
+    },
+    "./lexer": {
+      "import": "./lib/lexer/index.js",
+      "require": "./cjs/lexer/index.cjs"
+    },
+    "./definition-syntax": {
+      "import": "./lib/definition-syntax/index.js",
+      "require": "./cjs/definition-syntax/index.cjs"
+    },
+    "./definition-syntax-data": {
+      "import": "./lib/data.js",
+      "require": "./cjs/data.cjs"
+    },
+    "./definition-syntax-data-patch": {
+      "import": "./lib/data-patch.js",
+      "require": "./cjs/data-patch.cjs"
+    },
+    "./utils": {
+      "import": "./lib/utils/index.js",
+      "require": "./cjs/utils/index.cjs"
+    }
+  },
+  "browser": {
+    "./cjs/data.cjs": "./dist/data.cjs",
+    "./cjs/version.cjs": "./dist/version.cjs",
+    "./lib/data.js": "./dist/data.js",
+    "./lib/version.js": "./dist/version.js"
+  },
+  "unpkg": "dist/csstree.esm.js",
+  "jsdelivr": "dist/csstree.esm.js",
+  "scripts": {
+    "watch": "npm run build -- --watch",
+    "build": "npm run bundle && npm run esm-to-cjs --",
+    "build-and-test": "npm run build && npm run test:dist && npm run test:cjs",
+    "bundle": "node scripts/bundle",
+    "bundle-and-test": "npm run bundle && npm run test:dist",
+    "esm-to-cjs": "node scripts/esm-to-cjs.cjs",
+    "esm-to-cjs-and-test": "npm run esm-to-cjs && npm run test:cjs",
+    "lint": "eslint lib scripts && node scripts/review-syntax-patch --lint && node scripts/update-docs --lint",
+    "lint-and-test": "npm run lint && npm test",
+    "update:docs": "node scripts/update-docs",
+    "review:syntax-patch": "node scripts/review-syntax-patch",
+    "test": "mocha lib/__tests --require lib/__tests/helpers/setup.js --reporter progress",
+    "test:cjs": "mocha cjs/__tests --require lib/__tests/helpers/setup.js --reporter progress",
+    "test:dist": "mocha dist/__tests --reporter progress",
+    "coverage": "c8 --exclude lib/__tests --reporter=lcovonly npm test",
+    "prepublishOnly": "npm run lint-and-test && npm run build-and-test",
+    "test:types": "tsc -p tests/types/tsconfig.json"
+  },
+  "dependencies": {
+    "mdn-data": "^2.18.0",
+    "source-map-js": "^1.0.1"
+  },
+  "devDependencies": {
+    "c8": "^7.12.0",
+    "clap": "^2.0.1",
+    "esbuild": "^0.24.0",
+    "eslint": "^8.4.1",
+    "json-to-ast": "^2.1.0",
+    "mocha": "^9.2.2",
+    "rollup": "^2.79.2",
+    "typescript": "^5.7.3"
+  },
+  "engines": {
+    "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+  },
+  "files": [
+    "data",
+    "dist",
+    "cjs",
+    "!cjs/__tests",
+    "lib",
+    "!lib/__tests"
+  ]
+}