@podlite/schema 0.0.10 → 0.0.12

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 # @podlite/schema
 
 ## Upcoming
+## 0.0.12
+- add helpers,
+- fix parser's grammars
+- add tests
+- update deps
+## 0.0.11
+- extend API by context for react component wrap function
 ## 0.0.10
 - fix helper for mkBlock
 - add Strikethrough inline element support

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Alexandr Zahatski
+Copyright © 2021-2024 Aliaksandr Zahatski
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/ast-helpers.d.ts

@@ -1 +1,2 @@
 export declare const getNodeId: (node: any, ctx: any) => any;
+export declare const makeAttrs: (node: any, ctx?: import("./helpers/config").Context) => import("./helpers/config").Attr;

package/lib/ast-helpers.js

@@ -3,8 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNodeId = void 0;
-const config_1 = __importDefault(require("pod6/built/helpers/config"));
+exports.makeAttrs = exports.getNodeId = void 0;
+const config_1 = __importDefault(require("./helpers/config"));
 const getNodeId = (node, ctx) => {
     const conf = (0, config_1.default)(node, ctx);
     if (conf.exists('id')) {
@@ -13,3 +13,4 @@ const getNodeId = (node, ctx) => {
     return node.id;
 };
 exports.getNodeId = getNodeId;
+exports.makeAttrs = config_1.default;

package/lib/ast-inerator.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeInterator = exports.isSemanticBlock = exports.isNamedBlock = void 0;
-const { makeRule, makePlug } = require('pod6/built/helpers/makeQuery');
+const makeQuery_1 = require("./helpers/makeQuery");
 // the following names: MyBlock, myBlock are use for extending pod6
 function isNamedBlock(name) {
     return (name
@@ -35,7 +35,7 @@ const makeInterator = (rule) => {
             }
             return [];
         }
-        rules.push(makeRule(makePlug(key), fn));
+        rules.push((0, makeQuery_1.makeRule)((0, makeQuery_1.makePlug)(key), fn));
     }
     function visiter(node, context = {}) {
         if (node instanceof Array) {

package/lib/exportAny.d.ts

@@ -0,0 +1,19 @@
+export declare type Options = {
+    processor?: any;
+    writer?: any;
+};
+export declare const toAny: (options?: Options, plugins?: any[]) => {
+    (root: any): void;
+    use: (key: any, fn?: any) => any;
+    run: (src: any, opt_writer?: any) => {
+        errors: any;
+        toString: () => string;
+        valueOf: () => string;
+        indexingTerms: any;
+        annotations: any;
+        defenitions: any;
+        interator: any;
+    };
+    getPlugins(): any[];
+};
+export default toAny;

package/lib/exportAny.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAny = void 0;
+const makeQuery_1 = require("./helpers/makeQuery");
+const makeInterator_1 = __importDefault(require("./helpers/makeInterator"));
+const writer_1 = __importDefault(require("./writer"));
+const _1 = require("./");
+const toAny = (options = {}, plugins = []) => {
+    let fns = plugins;
+    // setup pod6 processor
+    const processor = options.processor || _1.parse;
+    const _writer = options.writer;
+    chain.use = use;
+    chain.run = run;
+    chain.getPlugins = () => fns;
+    return chain;
+    function chain(root) {
+    }
+    function use(key, fn) {
+        if (key instanceof Array) {
+            return (0, exports.toAny)(options, [...fns, ...fn]);
+        }
+        if (key instanceof Object) {
+            for (var prop in key) {
+                if (key.hasOwnProperty(prop)) {
+                    use(prop, key[prop]);
+                }
+            }
+            return chain;
+        }
+        fns.push((0, makeQuery_1.makeRule)((0, makeQuery_1.makePlug)(key), fn));
+        return chain;
+    }
+    function run(src, opt_writer) {
+        let res = '';
+        const _tmp_writer = opt_writer || _writer || new writer_1.default((s) => { res = res + s; });
+        const writer = ('function' === typeof _tmp_writer) ? new _tmp_writer((s) => { res = res + s; }) : _tmp_writer;
+        // src may be preparsed tree
+        const tree = ("string" === typeof src) ? processor(src) : src;
+        // make new instance of HTML with initialized plugins
+        // reverse init
+        let newFns = fns.slice();
+        newFns.reverse();
+        const interator = (0, makeInterator_1.default)(newFns.map(rule => (0, makeQuery_1.makeRule)(rule.rule, rule.fn(writer, processor, tree))).reverse());
+        const context = {};
+        writer.startWrite(tree);
+        const result = interator(tree, context);
+        writer.endWrite();
+        return {
+            errors: writer.errors,
+            toString: () => res,
+            valueOf: () => res,
+            indexingTerms: writer.INDEXTERMS,
+            annotations: writer.FOOTNOTES,
+            defenitions: writer.DEFINITIONS,
+            interator: result
+        };
+    }
+};
+exports.toAny = toAny;
+exports.default = exports.toAny;

package/lib/exportHtml.d.ts

@@ -0,0 +1,15 @@
+declare const toHtml: (opt: any) => {
+    (root: any): void;
+    use: (key: any, fn?: any) => any;
+    run: (src: any, opt_writer?: any) => {
+        errors: any;
+        toString: () => string;
+        valueOf: () => string;
+        indexingTerms: any;
+        annotations: any;
+        defenitions: any;
+        interator: any;
+    };
+    getPlugins(): any[];
+};
+export default toHtml;

package/lib/exportHtml.js

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exportAny_1 = __importDefault(require("./exportAny"));
+const handlers_1 = require("./helpers/handlers");
+const makeTransformer_1 = require("./helpers/makeTransformer");
+const config_1 = __importDefault(require("./helpers/config"));
+const writerHtml_1 = __importDefault(require("./writerHtml"));
+const plugin_clean_location_1 = __importDefault(require("./plugin-clean-location"));
+const ast_helpers_1 = require("./ast-helpers");
+const rules = {
+    ':text': (writer, processor) => (node, ctx, interator) => {
+        // handle text with content
+        if (node.value) {
+            writer.write(node.value);
+        }
+        else {
+            interator(node.content, ctx);
+        }
+    },
+    // Formatting codes
+    'A<>': (writer, processor) => (node, ctx, interator) => {
+        //get replacement text
+        if (!(ctx.alias && ctx.alias.hasOwnProperty(node.content))) {
+            writer.write(`A<${node.content}>`);
+        }
+        else {
+            const src = ctx.alias[node.content].join('\n');
+            const tree_1 = processor(src);
+            // now clean locations
+            const tree = (0, plugin_clean_location_1.default)()(tree_1);
+            if (tree[0].type === 'para') {
+                interator(tree[0].content, ctx);
+            }
+            else {
+                interator(tree, ctx);
+            }
+        }
+    },
+    'C<>': (0, handlers_1.wrapContent)('<code>', '</code>'),
+    'D<>': (writer, processor) => (node, ctx, interator) => {
+        // @ts-ignore
+        let synonyms = { node };
+        let definition = [node.content[0]];
+        if (synonyms) {
+            definition = synonyms;
+        }
+        if (!writer.hasOwnProperty('DEFINITIONS')) {
+            writer.DEFINITIONS = [];
+        }
+        writer.DEFINITIONS.push({ definition });
+        writer.writeRaw('<dfn>');
+        interator(node.content, ctx);
+        writer.writeRaw('</dfn>');
+    },
+    'B<>': (0, handlers_1.wrapContent)('<strong>', '</strong>'),
+    'I<>': (0, handlers_1.wrapContent)('<em>', '</em>'),
+    'R<>': (0, handlers_1.wrapContent)('<var>', '</var>'),
+    'K<>': (0, handlers_1.wrapContent)('<kbd>', '</kbd>'),
+    "L<>": (0, handlers_1.setFn)((node, ctx) => {
+        let { meta } = node;
+        if (meta === null) {
+            meta = node.content;
+        }
+        return (0, handlers_1.wrapContent)(`<a href="${meta}">`, `</a>`);
+    }),
+    /**
+     * CSS rules for footnotes
+     
+    .footnote a {
+        text-decoration: none;
+    }
+    .footnotes {
+    border-top-style: solid;
+    border-top-width: 1px;
+    border-top-color: #eee;
+    }
+     */
+    'N<>': (writer, processor) => {
+        writer.addListener('end', () => {
+            if (!writer.hasOwnProperty('FOOTNOTES')) {
+                return;
+            }
+            const footnotes = writer.FOOTNOTES;
+            if (footnotes.length < 1) {
+                return;
+            } // if empty footnotes
+            writer.writeRaw(`<div class="footnotes">`);
+            footnotes.map((footnote) => {
+                writer.writeRaw(`<p><sup id="${footnote.fnId}" class="footnote"><a href="#${footnote.fnRefId}">[${footnote.gid}]</a></sup> `);
+                footnote.make();
+                writer.writeRaw(`</p>`);
+            });
+            writer.writeRaw(`</div>`);
+        });
+        return (node, ctx, interator) => {
+            // skip empty notes
+            if (node.content.length < 1) {
+                return;
+            }
+            if (!writer.hasOwnProperty('gid')) {
+                writer.gid = 1;
+            }
+            // get foot note id
+            const gid = writer.gid++;
+            const fnRefId = `fnref:${gid}`;
+            const fnId = `fn:${gid}`;
+            writer.writeRaw(`<sup id="${fnRefId}" class="footnote"><a href="#${fnId}">[${gid}]</a></sup>`);
+            if (!writer.hasOwnProperty('FOOTNOTES')) {
+                writer.FOOTNOTES = [];
+            }
+            writer.FOOTNOTES.push({
+                gid,
+                fnRefId,
+                fnId,
+                make: () => { interator(node.content, ctx); }
+            });
+        };
+    },
+    'S<>': (writer, processor) => (node, ctx, interator) => {
+        const content = node.content || '';
+        const spaces = content.replace(/ /g, '&nbsp;');
+        const newFeed = spaces.replace(/\n/g, '</br>');
+        writer.writeRaw(newFeed);
+    },
+    'T<>': (0, handlers_1.wrapContent)('<samp>', '</samp>'),
+    'U<>': (0, handlers_1.wrapContent)('<u>', '</u>'),
+    'V<>': handlers_1.content,
+    'X<>': (writer, processor) => (node, ctx, interator) => {
+        interator(node.content, ctx);
+        let { entry } = node;
+        if (entry === null && node.content.length > 0) {
+            //@ts-ignore
+            entry = [node.content[0]];
+        }
+        else {
+            return;
+        }
+        if (!writer.hasOwnProperty('INDEXTERMS')) {
+            writer.INDEXTERMS = [];
+        }
+        writer.INDEXTERMS.push({
+            entry
+        });
+    },
+    'Z<>': handlers_1.emptyContent,
+    'pod': handlers_1.content,
+    ':code': (0, handlers_1.wrapContent)('<pre><code>', '</code></pre>'),
+    'code': (0, handlers_1.handleNested)((0, handlers_1.wrapContent)('<pre><code>', '</code></pre>')),
+    'data': handlers_1.emptyContent,
+    ':verbatim': (writer, processor) => (node, ctx, interator) => {
+        if (node.error) {
+            writer.emit("errors", node.location);
+        }
+        interator(node.value);
+    },
+    ':blankline': handlers_1.emptyContent,
+    ':ambient': handlers_1.emptyContent,
+    // Directives 
+    ':config': (0, handlers_1.setFn)((node, ctx) => {
+        // setup context
+        if (!ctx.hasOwnProperty('config'))
+            ctx.config = {};
+        //collect configs in context
+        ctx.config[node.name] = node.config;
+        return handlers_1.emptyContent;
+    }),
+    ':alias': (0, handlers_1.setFn)((node, ctx) => {
+        // set alias
+        if (!ctx.hasOwnProperty('alias'))
+            ctx.alias = {};
+        //collect configs in context
+        ctx.alias[node.name] = node.replacement;
+        return handlers_1.emptyContent;
+    }),
+    // block =para
+    'para': (0, handlers_1.handleNested)(handlers_1.content),
+    ':para': (0, handlers_1.wrapContent)('<p>', '</p>'),
+    'head:block': (0, handlers_1.subUse)({
+        // inside head don't wrap into <p>
+        ':para': handlers_1.content,
+    }, (0, handlers_1.setFn)((node, ctx) => {
+        const { level } = node;
+        const id = (0, ast_helpers_1.getNodeId)(node, ctx);
+        return (0, handlers_1.wrapContent)(`<h${level}${id ? ` id="${id}"` : ''}>`, `</h${level}>`);
+    })),
+    ':list': (0, handlers_1.setFn)((node, ctx) => node.list === 'ordered' ? (0, handlers_1.wrapContent)('<ol>', '</ol>')
+        : node.list === 'variable' ? (0, handlers_1.wrapContent)('<dl>', '</dl>')
+            : (0, handlers_1.wrapContent)('<ul>', '</ul>')),
+    'item:block': (writer, processor) => (node, ctx, interator) => {
+        // make text from first para
+        if (!(node.content instanceof Array)) {
+            console.error('[pod6] item:block : Error in content of ' + JSON.stringify(node));
+        }
+        const [firstPara, ...other] = node.content;
+        writer.writeRaw('<li>');
+        // TODO: get cases for handle first para in items
+        // interator([...firstPara.content, ...other], ctx)
+        interator(node.content, ctx);
+        writer.writeRaw('</li>');
+    },
+    'comment:block': handlers_1.emptyContent,
+    'defn': (0, handlers_1.wrapContent)('', '</dd>'),
+    'term:para': (0, handlers_1.wrapContent)('<dt>', '</dt><dd>'),
+    'nested': (0, handlers_1.handleNested)(handlers_1.content, 1),
+    'output': (0, handlers_1.handleNested)((0, handlers_1.wrapContent)('<pre><samp>', '</samp></pre>'), 1),
+    'input': (0, handlers_1.handleNested)((0, handlers_1.wrapContent)('<pre><kbd>', '</kbd></pre>'), 1),
+    // table section
+    'table:block': (0, handlers_1.handleNested)((writer, processor) => (node, ctx, interator) => {
+        const conf = (0, config_1.default)(node, ctx);
+        writer.writeRaw('<table>');
+        if (conf.exists('caption')) {
+            writer.writeRaw('<caption>');
+            writer.write(conf.getFirstValue('caption'));
+            writer.writeRaw('</caption>');
+        }
+        interator(node.content, ctx);
+        writer.writeRaw('</table>');
+    }),
+    ':separator': handlers_1.emptyContent,
+    'table_row': (0, handlers_1.wrapContent)('<tr>', '</tr>'),
+    'table_cell': (0, handlers_1.wrapContent)('<td>', '</td>'),
+    'table_head': (0, handlers_1.subUse)({
+        'table_cell': (0, handlers_1.wrapContent)('<th>', '</th>')
+    }, (0, handlers_1.wrapContent)('<tr>', '</tr>')),
+    // Toc
+    ':toc': (writer, processor) => (node, ctx, interator) => {
+        writer.writeRaw('<div className="toc">');
+        // get toc title
+        const conf = (0, config_1.default)(node, ctx);
+        if (conf.exists('title')) {
+            const title = conf.getFirstValue('title');
+            writer.writeRaw('<div className="toctitle">');
+            writer.write(title);
+            writer.writeRaw('</div>');
+        }
+        interator(node.content, ctx);
+        writer.writeRaw('</div>');
+    },
+    ':toc-list': (0, handlers_1.setFn)((node, ctx) => (0, handlers_1.wrapContent)(`<ul class="toc-list listlevel${node.level}">`, '</ul>')),
+    ':toc-item': (0, handlers_1.setFn)((node, ctx) => (0, handlers_1.wrapContent)('<li class="toc-item">', '</li>')),
+    ':image': (writer, processor) => (node, ctx, interator) => {
+        writer.writeRaw(`<img src="${node.src}" alt="${node.alt}"/>`);
+    }
+};
+const toHtml = (opt) => (0, exportAny_1.default)({ writer: writerHtml_1.default, ...opt }).use('*', (writer, processor) => {
+    return (node, ctx, interator) => {
+        // skip warnings for semantic blocks
+        const isSemanticBlock = (node) => {
+            const name = node.name || '';
+            const isTypeBlock = (node.type || '') === 'block';
+            return isTypeBlock && name === name.toUpperCase();
+        };
+        //Named blocks for which no explicit class has been defined or loaded are
+        //usually not rendered by the standard renderers.
+        if ((0, makeTransformer_1.isNamedBlock)(node.name)) {
+            return true;
+        }
+        if (isSemanticBlock(node)) {
+            const name = node.name;
+            writer.writeRaw('<h1 class="');
+            writer.write(name);
+            writer.writeRaw('">');
+            writer.write(name);
+            writer.writeRaw('</h1>');
+        }
+        else {
+            console.warn("[pod6] Unhandled node" + JSON.stringify(node, null, 2));
+        }
+        if (node.hasOwnProperty('content')) {
+            interator(node.content, ctx);
+        }
+    };
+}).use(rules);
+exports.default = toHtml;

package/lib/grammar.d.ts

@@ -0,0 +1,14 @@
+declare function peg$SyntaxError(message: any, expected: any, found: any, location: any): void;
+declare class peg$SyntaxError {
+    constructor(message: any, expected: any, found: any, location: any);
+    message: any;
+    expected: any;
+    found: any;
+    location: any;
+    name: string;
+}
+declare namespace peg$SyntaxError {
+    function buildMessage(expected: any, found: any): string;
+}
+declare function peg$parse(input: any, options: any): any;
+export { peg$SyntaxError as SyntaxError, peg$parse as parse };