@podlite/schema 0.0.11 → 0.0.13

package/lib/plugin-group-items.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("./helpers/config"));
+exports.default = () => tree => {
+    const isNodesEqual = (n1, n2) => 
+    // if nodes items
+    (n1.name === 'item' || n1.name === 'defn') &&
+        n2.name === n1.name &&
+        n1['level'] === n2.level &&
+        isNumbered(n1) === isNumbered(n2);
+    const isNumbered = node => Boolean((0, config_1.default)(node, {}).exists('numbered'));
+    const group = (a, level = 1) => {
+        const isInListMode = a => {
+            return a.length > 0 && a[a.length - 1].type === 'list';
+        };
+        const getList = a => {
+            if (isInListMode(a))
+                return a[a.length - 1];
+        };
+        const isInsertableToList = (l, i) => (i.name && i.name === 'item' && i.type && i.type === 'block') || i.type === 'blankline';
+        let lastItem = {};
+        let result = a.reduce((a, i) => {
+            // skip items out of level
+            if (i.name === 'item' && i.type === 'block' && i.level < level) {
+                return [...a, i];
+            }
+            if (i.name === 'item' &&
+                i.type === 'block' &&
+                (!isInListMode(a) ||
+                    // different type of list and item
+                    // at the same  level
+                    (i.level === level && getList(a).list !== (isNumbered(i) ? 'ordered' : 'itemized')))) {
+                // create empty list
+                // list = ['ordered', 'variable', 'itemized']
+                a.push({
+                    type: 'list',
+                    level: i.level,
+                    content: [],
+                    list: isNumbered(i) ? 'ordered' : 'itemized',
+                });
+            }
+            // main logic
+            if (isInListMode(a) && isInsertableToList(getList(a), i)) {
+                // getlist and push item to them
+                getList(a).content.push(i);
+            }
+            else {
+                a.push(i);
+            }
+            return a;
+        }, []);
+        // convert grouped items into object 'itemlist'
+        /**
+         * { type = 'list',
+         *   ordered = [true, false]
+         *   content = [ .... ]
+         *   list = ['ordered', 'variable', 'itemized']
+         */
+        return result.map(item => {
+            // process any item with content ( except formatting codes)
+            if (item.content && item.type !== 'fcode') {
+                item.content = group(item.content, item.level + 1);
+            }
+            return item;
+        });
+    };
+    const visit = node => {
+        if (Array.isArray(node)) {
+            node = group(node);
+        }
+        else {
+            if (node.type === 'block' && node.name !== 'table') {
+                node.content = group(node.content);
+            }
+        }
+        return node;
+    };
+    tree = visit(tree);
+    return tree;
+};
+//# sourceMappingURL=plugin-group-items.js.map

package/lib/plugin-heading.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-heading.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => tree => {
+    const visit = node => {
+        if (Array.isArray(node)) {
+            node.forEach(i => {
+                visit(i);
+            });
+        }
+        else {
+            if (node && node.type === 'block') {
+                const matchHead = /^head(\d+)?/.exec(node.name);
+                if (matchHead) {
+                    node.name = 'head';
+                    node.level = matchHead[1] || 1;
+                    if (node.content[0]) {
+                        const startText = node.content[0];
+                        if (startText.text) {
+                            let re = /(\s*#\s*)/;
+                            const match = re.exec(startText.text);
+                            if (match) {
+                                startText.text = startText.text.replace(re, '');
+                                node.config = { ...node.config, ...{ numbered: true } };
+                            }
+                        }
+                    }
+                }
+                visit(node.content);
+            }
+        }
+    };
+    visit(tree);
+    return tree;
+};
+//# sourceMappingURL=plugin-heading.js.map

package/lib/plugin-items.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-items.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = () => tree => {
+    const visit = node => {
+        if (Array.isArray(node)) {
+            node.forEach(i => {
+                visit(i);
+            });
+        }
+        else {
+            if (node && node.type === 'block') {
+                const matchItem = /^item(\d+)?/.exec(node.name);
+                if (matchItem) {
+                    node.name = 'item';
+                    node.level = matchItem[1] || 1;
+                    if (node.content[0]) {
+                        const startText = node.content[0];
+                        if (startText.text) {
+                            let re = /^(\s*#\s*)/;
+                            const match = re.exec(startText.text);
+                            if (match) {
+                                startText.text = startText.text.replace(re, '');
+                                if (startText.type === 'para') {
+                                    startText.content = [startText.text];
+                                }
+                                node.config = node.config || [];
+                                node.config.push({
+                                    name: 'numbered',
+                                    value: true,
+                                    type: 'boolean',
+                                });
+                            }
+                        }
+                    }
+                }
+                visit(node.content);
+            }
+        }
+    };
+    visit(tree);
+    return tree;
+};
+//# sourceMappingURL=plugin-items.js.map

package/lib/plugin-tables.d.ts

@@ -0,0 +1,5 @@
+declare const _default: () => (tree: any) => any;
+/**
+ *  Main transforms
+ */
+export default _default;

package/lib/plugin-tables.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Plugin for fill term's for defn. From S26:
+ * The first non-blank line of content is treated as a term being defined,
+ * and the remaining content is treated as the definition for the term.
+ */
+const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
+function flattenDeep(arr) {
+    return arr.reduce((acc, val) => (Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val)), []);
+}
+/**
+ *  Helpers section
+ */
+// run cb in symbols pair
+const strbin = (str1, str2, cb) => {
+    let res = [];
+    for (let i = 0; str1.length > i; i++) {
+        res.push(cb(parseInt(str1[i], 10), parseInt(str2[i], 10)));
+    }
+    return res.join('');
+};
+// Create mask for extract columns
+const makeMask = (lines, separators) => {
+    // calculate template length
+    const tmplLength = Math.max(...[...lines, ...separators].map(s => s.length));
+    // make bin mask for each string
+    const masks = lines.map(str => {
+        /** make mask for each line
+                    '        The Shoveller | Eddie Stevens   | King Arthur\'s singing shovel',
+                    '0000000011111111111110001111111111111000001111111111111111111111111111' ]
+                    then  not(mask) ... then  & masks
+                   */
+        // enlarge string to tmplLength
+        let tstr = str + ' '.repeat(tmplLength - str.length);
+        let mask = [];
+        const re = /\s+[+|\s]\s/g;
+        let match;
+        while ((match = re.exec(tstr)) != null) {
+            const tmpMask = '1'.repeat(match.index) + '0'.repeat(match[0].length);
+            mask.push(tmpMask + '1'.repeat(tmplLength - tmpMask.length));
+        }
+        return mask.reduce((a, b) => {
+            return strbin(a, b, (i1, i2) => i1 & i2);
+        }, '1'.repeat(tmplLength));
+    });
+    // make result mask
+    const inverted = masks.map(m => strbin(m, '', i1 => (i1 == 0 ? 1 : 0)));
+    const columnTemplate = inverted.reduce((a, b) => {
+        return strbin(a, b, (i1, i2) => i1 & i2);
+    }, '1'.repeat(tmplLength));
+    return columnTemplate;
+};
+const extractColumnsByTemplate = (text, template) => {
+    const lines = flattenDeep(text
+        .split(/\n/) // split each row by eol
+        .filter(str => str.length > 0));
+    const cols = lines.map(line => {
+        const re = /((1+|0+))/g;
+        let columns = [];
+        let match;
+        while ((match = re.exec(template)) != null) {
+            if (match[0][0] == 1)
+                continue;
+            const s = line.substring(match.index, match.index + match[0].length);
+            columns.push(s);
+        }
+        return columns;
+    });
+    let result = [];
+    result = cols.reduce((a, b) => {
+        for (let i = 0; i < b.length; i++) {
+            a[i] = (a[i] === undefined ? '' : a[i]) + ' ' + b[i];
+        }
+        return a;
+    }, []);
+    return result;
+};
+/**
+ *  Main transforms
+ */
+exports.default = () => tree => {
+    const transformer = (0, makeTransformer_1.default)({
+        table: node => {
+            let rows = [];
+            const collectValues = row => {
+                rows.push(row.value);
+            };
+            // collect separators for calculate max length of rows
+            let seps = [];
+            (0, makeTransformer_1.default)({
+                'row:text': collectValues,
+                'head:text': collectValues,
+                ':separator': sep => {
+                    seps.push(sep.text);
+                },
+            })(node);
+            // add table-caption
+            // if table empty return node as is
+            if (!rows.length)
+                return node;
+            const splitToLines = row => row
+                .split(/\n/) // split each row by eol
+                .filter(str => str.length > 0); // filter empty strings ( after slit )
+            // split each row into lines
+            const lines = flattenDeep(rows.map(splitToLines));
+            const separators = flattenDeep(seps.map(splitToLines));
+            // collect text rows
+            let textRows = [];
+            (0, makeTransformer_1.default)({
+                'row:text': row => {
+                    textRows.push(row.value);
+                },
+            })(node);
+            const columnTemplate = makeMask(lines, separators);
+            const makeBlock = (name, content, ...attr) => {
+                return { ...attr, name, type: 'block', content: Array.isArray(content) ? content : [content] };
+            };
+            // make columns
+            const res = (0, makeTransformer_1.default)({
+                'row:text': row => {
+                    if (textRows.length == 1) {
+                        // split each text row into lines
+                        const textRowsLines = flattenDeep([row.value].map(splitToLines));
+                        return textRowsLines.map(rowValue => {
+                            const res = extractColumnsByTemplate(rowValue, columnTemplate);
+                            return makeBlock('table_row', res.map(col => makeBlock('table_cell', { type: 'text', value: col })));
+                        });
+                    }
+                    const res = extractColumnsByTemplate(row.value, columnTemplate);
+                    return makeBlock('table_row', res.map(col => makeBlock('table_cell', { type: 'text', value: col })));
+                },
+                'head:text': head => {
+                    const res = extractColumnsByTemplate(head.value, columnTemplate);
+                    return makeBlock('table_head', res.map(col => makeBlock('table_cell', { type: 'text', value: col })));
+                },
+            })(node);
+            return res;
+        },
+    });
+    return transformer(tree, {});
+};
+//# sourceMappingURL=plugin-tables.js.map

package/lib/plugin-vmargin.d.ts

@@ -0,0 +1,3 @@
+import { ParserPlugin } from './';
+declare const middle: ParserPlugin;
+export default middle;

package/lib/plugin-vmargin.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const middle = () => tree => {
+    const visit_node = (node, context = {}) => {
+        // if( (node.type || "").match(/(code|text)/) ) {
+        if (node.type == 'code' || node.type == 'text') {
+            if (node.margin && context.margin && context.margin.length > 0 && context.margin.length == node.margin.length) {
+                ;
+                node.type = 'para';
+            }
+            if (node.type === 'code') {
+                // remove parent margin
+                var regex = new RegExp(`^[ \t]{0,${node.margin.length}}`, 'gm');
+                node.text = node.text.replace(regex, '');
+            }
+        }
+        if (node.type === 'block') {
+            context.margin = typeof node.margin !== 'string' ? '' : node.margin;
+            let newctx = { ...context };
+            newctx.nest = (newctx.nest || 0) + 1;
+            node.content.map(n => {
+                visit_node(n, context);
+            });
+        }
+    };
+    var ctx = {};
+    tree.forEach(n => visit_node(n, ctx));
+    return tree;
+};
+exports.default = middle;
+//# sourceMappingURL=plugin-vmargin.js.map

package/lib/query-helpers.d.ts

@@ -1,3 +1,4 @@
+import { PodNode } from './types';
 declare type Query = ((par: Object) => Boolean) | any;
 /**
  * compileQuery - compile a query to a function
@@ -23,5 +24,5 @@ export declare const compileQuery: (...obj: Query[]) => (any: any) => any;
  * @param queries
  * @returns array of matched nodes
  */
-export declare const getFromTree: (tree: any, ...queries: string[] | any) => any;
+export declare const getFromTree: (tree: any, ...queries: string[] | any) => PodNode[];
 export {};

package/lib/query-helpers.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFromTree = exports.compileQuery = void 0;
-const makeTransformer_1 = __importDefault(require("pod6/built/helpers/makeTransformer"));
+const _1 = require("./");
 /**
  * compileQuery - compile a query to a function
     
@@ -34,7 +31,7 @@ const compileQuery = (...obj) => {
             }
             else {
                 // obj should accomplished if some queries is true
-                if (compiledQueries.some((fn) => fn(item).length > 0)) {
+                if (compiledQueries.some(fn => fn(item).length > 0)) {
                     result.push(item);
                 }
             }
@@ -46,7 +43,7 @@ exports.compileQuery = compileQuery;
 const compileAtomQuery = (obj) => {
     const queries = [];
     if (obj instanceof Array) {
-        throw new Error("Wrong query parameter [Array], should be [Function] or [Object]");
+        throw new Error('Wrong query parameter [Array], should be [Function] or [Object]');
     }
     else if (typeof obj === 'function') {
         queries.push(obj);
@@ -54,7 +51,7 @@ const compileAtomQuery = (obj) => {
     else {
         for (const entry of Object.entries(obj)) {
             const [key, value] = entry;
-            const checkValue = (val) => {
+            const checkValue = val => {
                 if (value instanceof Array) {
                     return value.includes(val);
                 }
@@ -84,7 +81,7 @@ const compileAtomQuery = (obj) => {
                 result.push(...AND(item));
             }
             // obj should accomplished if all queries to be true
-            if (queries.every((fn) => fn(item))) {
+            if (queries.every(fn => fn(item))) {
                 result.push(item);
             }
         });
@@ -103,12 +100,14 @@ const getFromTree = (tree, ...queries) => {
     }
     let results = [];
     let rules = {};
-    const transformer = (0, makeTransformer_1.default)({ '*:*': (node, ctx) => {
+    const transformer = (0, _1.makeTransformer)({
+        '*:*': (node, ctx) => {
             results.push(node);
             if ('content' in node) {
                 return { node, content: transformer(node.content, { ...ctx }) };
             }
-        } });
+        },
+    });
     transformer(tree, {});
     //convert queries
     const queryAtoms = [];
@@ -134,3 +133,4 @@ const getFromTree = (tree, ...queries) => {
     return (0, exports.compileQuery)(...queryAtoms)(results);
 };
 exports.getFromTree = getFromTree;
+//# sourceMappingURL=query-helpers.js.map