Function filePathToClassnameDict

src/utils.ts:273–418

(
    filepath: string,
    classnameTransformer: StringTransformer,
)

 * ```
 */
export async function filePathToClassnameDict(
    filepath: string,
    classnameTransformer: StringTransformer,
): Promise<ClassnameDict> {
    const content = fs.readFileSync(filepath, {encoding: 'utf8'});
    const EOL = getEOL(content);
    const {ext} = path.parse(filepath);

    /**
     * only load the parses once they are needed
     */
    const parsers: Record<string, undefined | LazyLoadPostcssParser> = {
        '.less': () => require('postcss-less'),
        '.scss': () => require('postcss-scss'),
        '.sass': () => require('postcss-sass'),
    };

    const getParser = parsers[ext];

    /**
     * Postcss does not expose this option though typescript types
     * This is why we are doing this naughty thingy
     */
    const hiddenOption = {hideNothingWarning: true} as Record<never, never>;
    const postcssOptions: ProcessOptions = {
        map: false,
        from: filepath,
        ...hiddenOption,
        ...(typeof getParser === 'function' ? {parser: getParser()} : {}),
    };

    const ast = await PostcssInst.process(content, postcssOptions);
    // TODO: root.walkRules and for each rule gather info about parents
    const dict: ClassnameDict = {};

    const visitedNodes = new Map<Node, {selectors: string[]}>([]);
    const stack = [...ast.root.nodes];
    let commentStack: Comment[] = [];

    while (stack.length) {
        const node = stack.shift();
        if (node === undefined) continue;
        if (node.type === 'comment') {
            commentStack.push(node);
            continue;
        }
        if (node.type === 'atrule') {
            if (
                AT_RULES_WITH_SELECTORS.has(node.name.toLowerCase()) &&
                node.nodes
            ) {
                stack.unshift(...node.nodes);
            }
            commentStack = [];
            continue;
        }
        if (node.type !== 'rule') continue;