@podlite/schema 0.0.11 → 0.0.13

package/lib/exportHtml.js

@@ -0,0 +1,284 @@
+"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;
+//# sourceMappingURL=exportHtml.js.map

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 };