@podlite/schema/lib/helpers/handlers.js

AST tools for Podlite markup language

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.handleNested = exports.subUse = exports.setContext = exports.setFn = exports.content = exports.emptyContent = exports.wrapContent = void 0;
const makeQuery_1 = require("./makeQuery");
const makeInterator_1 = __importDefault(require("./makeInterator"));
const config_1 = __importDefault(require("./config"));
/**
 * wrap content by open and closed tags
 */
const wrapContent = (pre, post) => (writer, processor) => (node, ctx, interator) => {
    writer.writeRaw(pre);
    if (node.content)
        interator(node.content, ctx);
    writer.writeRaw(post);
};
exports.wrapContent = wrapContent;
/**
 * emptyContent - skip any child node
 */
const emptyContent = () => () => () => { };
exports.emptyContent = emptyContent;
/**
 * content - process childs as regular content
 */
const content = (writer, processor) => (node, ctx, interator) => {
    if (node.content) {
        return interator(node.content, ctx);
    }
};
exports.content = content;
/**

Set hander after call with node

':para':setFn((node,ctx) => (ctx.parents || [] ).includes('head') ? content : wrapContent('<p>','</p>'),

*/
const setFn = (check) => (writer, processor) => {
    return (node, ctx, interator) => {
        return check(node, ctx)(writer, processor)(node, ctx, interator);
    };
};
exports.setFn = setFn;
/**

Set new context for handler

        const parents = (ctx.parents || [])
        parents.push('head')
        const {level} = node
        return setContext( { ...ctx, parents }, wrapContent(`<h${level}>`,`</h${level}>`))

*/
const setContext = (ctx, fn) => (writer, processor) => {
    return (node, _, interator) => {
        return fn(writer, processor)(node, ctx, interator);
    };
};
exports.setContext = setContext;
/**
 * Select handler from already inited wrappers
 *
 * @param {*} check
 * @param  {...any} fns
 */
const IfNode = (check, ...fns) => (writer, processor) => {
    return (node, ctx, interator) => {
        check(node, ctx, ...fns.map(i => i(writer, processor)))(node, ctx, interator);
    };
};
/**
 * Make subset of rules for processing
 *
 * @param {*} rules
 * @param {*} processNode
 */
const subUse = (rules, processNode) => {
    const newFns = (0, makeQuery_1.makeRulesArray)(rules).reverse();
    return (writer, processor) => {
        // init new rules
        const inited = newFns.map(item => (0, makeQuery_1.makeRule)(item.rule, item.fn(writer, processor))).reverse();
        const processNodeInited = processNode(writer, processor);
        let subInterator;
        return (node, ctx, interator) => {
            if (!subInterator)
                subInterator = (0, makeInterator_1.default)([...interator.rules, ...inited]);
            return processNodeInited(node, ctx, subInterator);
        };
    };
};
exports.subUse = subUse;
/**
 * Add support nesting
 *
 * @param {*} rules
 * @param {*} implicitLevel - default level of nesting
 *
 */
const handleNested = (defaultHandler, implicitLevel) => {
    return (writer, processor) => {
        const defaultHandlerInited = defaultHandler(writer, processor);
        return (node, ctx, interator) => {
            const nesting = (0, config_1.default)(node, ctx).getFirstValue('nested') || implicitLevel;
            // add nesting level
            if (nesting !== undefined) {
                writer.addLevel(nesting);
            }
            defaultHandlerInited(node, ctx, interator);
            // remove nesting level
            if (nesting !== undefined) {
                writer.removeLevel(nesting);
            }
        };
    };
};
exports.handleNested = handleNested;
//# sourceMappingURL=handlers.js.map