@mapcss/core/script/core/generate.js

Tiny, composable Atomic CSS engine

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.mapChar = exports.generate = void 0;
const deps_js_1 = require("../deps.js");
const extractor_js_1 = require("./extractor.js");
const resolve_js_1 = require("./resolve.js");
const escape_js_1 = require("./utils/escape.js");
const mod_js_1 = require("./postcss/mod.js");
const preprocess_js_1 = require("./preprocess.js");
const SEPARATOR = "-";
const VARIABLE_PREFIX = "map-";
const CHAR_MAP = { "_": " " };
const defaultSyntax = {
    name: "mapcss/default-syntax",
    fn: (identifier) => ({ identifier }),
};
/** Generate result of CSS Style Sheet */
function generate({ separator = SEPARATOR, variablePrefix = VARIABLE_PREFIX, charMap = CHAR_MAP, ...staticConfig }, input, { compress = false } = { compress: false }) {
    const ctx = {
        separator,
        variablePrefix,
        charMap,
    };
    const { syntax, modifierMap, theme, deepMapCSS, preProcess, postcssPlugin, css, } = (0, resolve_js_1.resolveConfig)(staticConfig, ctx);
    const staticContext = {
        ...ctx,
        theme,
    };
    const tokens = (0, deps_js_1.isString)(input) ? (0, extractor_js_1.extractSplit)(input) : input;
    const matched = new Set();
    const unmatched = new Set();
    const results = Array.from(tokens).map((token) => {
        let rootCache;
        const mappedToken = mapChar(token, charMap);
        for (const { fn } of [...syntax, defaultSyntax]) {
            const parseResult = fn(mappedToken, {
                ...staticContext,
                modifierRoots: Object.keys(modifierMap),
                identifierRoots: Array.from(deepMapCSS.keys()),
            });
            if (!parseResult)
                return;
            const { identifier, modifiers = [] } = parseResult;
            const className = `.${(0, escape_js_1.escapeSelector)(token)}`;
            const runtimeContext = {
                token,
                mappedToken,
                className,
            };
            const identifierRoot = (0, resolve_js_1.resolveDeepMapIdentifier)(identifier, deepMapCSS, {
                ...staticContext,
                ...runtimeContext,
                identifier,
            });
            if ((0, deps_js_1.isUndefined)(identifierRoot))
                continue;
            const results = modifiers.reduceRight((acc, cur) => {
                if ((0, deps_js_1.isUndefined)(acc))
                    return;
                return (0, resolve_js_1.resolveModifierMap)(cur, modifierMap, acc, {
                    ...staticContext,
                    ...runtimeContext,
                    modifier: cur,
                });
            }, identifierRoot);
            if (results instanceof deps_js_1.Root) {
                unmatched.delete(token);
                matched.add(token);
                rootCache = results;
                break;
            }
            unmatched.add(token);
        }
        return rootCache;
    }).filter(Boolean);
    const rootNode = results.reduce((acc, cur) => {
        acc.append(cur.nodes);
        return acc;
    }, new deps_js_1.Root());
    const final = [(0, preprocess_js_1.createInjectCSS)(css), ...preProcess].reduce((acc, cur) => cur.fn(acc, staticContext), rootNode);
    const corePostcssPlugins = [(0, mod_js_1.orderStatement)(), (0, mod_js_1.orderProp)()];
    const plugins = compress
        ? [...corePostcssPlugins, (0, mod_js_1.minify)()]
        : corePostcssPlugins;
    const ast = (0, deps_js_1.postcss)(...plugins, ...postcssPlugin).process(final).root;
    const result = {
        ast,
        get css() {
            return ast.toString();
        },
        get js() {
            return (0, deps_js_1.toObject)(ast);
        },
        matched,
        unmatched,
    };
    return result;
}
exports.generate = generate;
function mapChar(character, charMap) {
    let value = "";
    for (const char of character) {
        const c = (0, deps_js_1.prop)(char, charMap);
        if ((0, deps_js_1.isString)(c)) {
            value += c;
        }
        else {
            value += char;
        }
    }
    return value;
}
exports.mapChar = mapChar;