@podlite/schema 0.0.12 → 0.0.13

package/lib/plugin-group-items.js

@@ -4,46 +4,47 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_1 = __importDefault(require("./helpers/config"));
-exports.default = () => (tree) => {
-    const isNodesEqual = (n1, n2) => (
-    // if nodes items 
+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'));
+        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');
+        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)
-                ||
+            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')))) {
+                    (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'
+                    list: isNumbered(i) ? 'ordered' : 'itemized',
                 });
             }
             // main logic
-            if (isInListMode(a)
-                && isInsertableToList(getList(a), i)) { // getlist and push item to them
+            if (isInListMode(a) && isInsertableToList(getList(a), i)) {
+                // getlist and push item to them
                 getList(a).content.push(i);
             }
             else {
@@ -66,7 +67,7 @@ exports.default = () => (tree) => {
             return item;
         });
     };
-    const visit = (node) => {
+    const visit = node => {
         if (Array.isArray(node)) {
             node = group(node);
         }
@@ -80,3 +81,4 @@ exports.default = () => (tree) => {
     tree = visit(tree);
     return tree;
 };
+//# sourceMappingURL=plugin-group-items.js.map

package/lib/plugin-heading.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = () => (tree) => {
-    const visit = (node) => {
+exports.default = () => tree => {
+    const visit = node => {
         if (Array.isArray(node)) {
-            node.forEach(i => { visit(i); });
+            node.forEach(i => {
+                visit(i);
+            });
         }
         else {
             if (node && node.type === 'block') {
@@ -30,3 +32,4 @@ exports.default = () => (tree) => {
     visit(tree);
     return tree;
 };
+//# sourceMappingURL=plugin-heading.js.map

package/lib/plugin-items.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = () => (tree) => {
-    const visit = (node) => {
+exports.default = () => tree => {
+    const visit = node => {
         if (Array.isArray(node)) {
-            node.forEach(i => { visit(i); });
+            node.forEach(i => {
+                visit(i);
+            });
         }
         else {
             if (node && node.type === 'block') {
@@ -23,9 +25,9 @@ exports.default = () => (tree) => {
                                 }
                                 node.config = node.config || [];
                                 node.config.push({
-                                    "name": "numbered",
-                                    "value": true,
-                                    "type": "boolean"
+                                    name: 'numbered',
+                                    value: true,
+                                    type: 'boolean',
                                 });
                             }
                         }
@@ -38,3 +40,4 @@ exports.default = () => (tree) => {
     visit(tree);
     return tree;
 };
+//# sourceMappingURL=plugin-items.js.map

package/lib/plugin-tables.js

@@ -10,12 +10,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 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), []);
+    return arr.reduce((acc, val) => (Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val)), []);
 }
 /**
  *  Helpers section
  */
-// run cb in symbols pair        
+// run cb in symbols pair
 const strbin = (str1, str2, cb) => {
     let res = [];
     for (let i = 0; str1.length > i; i++) {
@@ -28,33 +28,36 @@ 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) => {
+    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
-         */
+                    '        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 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);
+            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));
+        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));
+    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) // filter empty strings ( after slit )
-    );
+    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 = [];
@@ -79,53 +82,65 @@ const extractColumnsByTemplate = (text, template) => {
 /**
  *  Main transforms
  */
-exports.default = () => (tree) => {
-    const transformer = (0, makeTransformer_1.default)({ 'table': (node) => {
+exports.default = () => tree => {
+    const transformer = (0, makeTransformer_1.default)({
+        table: node => {
             let rows = [];
-            const collectValues = (row) => { rows.push(row.value); };
+            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); }
+                ':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 )
+            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); }
+                '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] }; };
+            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) => {
+                'row:text': row => {
                     if (textRows.length == 1) {
                         // split each text row into lines
                         const textRowsLines = flattenDeep([row.value].map(splitToLines));
-                        return textRowsLines.map((rowValue) => {
+                        return textRowsLines.map(rowValue => {
                             const res = extractColumnsByTemplate(rowValue, columnTemplate);
-                            return makeBlock('table_row', res.map((col) => makeBlock('table_cell', { type: 'text', value: col })));
+                            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 })));
+                    return makeBlock('table_row', res.map(col => makeBlock('table_cell', { type: 'text', value: col })));
                 },
-                'head:text': (head) => {
+                'head:text': head => {
                     const res = extractColumnsByTemplate(head.value, columnTemplate);
-                    return makeBlock('table_head', res.map((col) => makeBlock('table_cell', { type: 'text', value: col })));
+                    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.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const middle = () => (tree) => {
+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') {
@@ -17,13 +18,14 @@ const middle = () => (tree) => {
             context.margin = typeof node.margin !== 'string' ? '' : node.margin;
             let newctx = { ...context };
             newctx.nest = (newctx.nest || 0) + 1;
-            node.content.map((n) => {
+            node.content.map(n => {
                 visit_node(n, context);
             });
         }
     };
     var ctx = {};
-    tree.forEach((n) => visit_node(n, ctx));
+    tree.forEach(n => visit_node(n, ctx));
     return tree;
 };
 exports.default = middle;
+//# sourceMappingURL=plugin-vmargin.js.map

package/lib/query-helpers.js

@@ -31,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);
                 }
             }
@@ -43,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);
@@ -51,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);
                 }
@@ -81,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);
             }
         });
@@ -100,12 +100,14 @@ const getFromTree = (tree, ...queries) => {
     }
     let results = [];
     let rules = {};
-    const transformer = (0, _1.makeTransformer)({ '*:*': (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 = [];
@@ -131,3 +133,4 @@ const getFromTree = (tree, ...queries) => {
     return (0, exports.compileQuery)(...queryAtoms)(results);
 };
 exports.getFromTree = getFromTree;
+//# sourceMappingURL=query-helpers.js.map

package/lib/types.d.ts

@@ -28,8 +28,8 @@ export interface RulesStrict {
     'U<>': RuleHandler<FormattingCodeAny>;
     'Z<>': RuleHandler<FormattingCodeAny>;
     'Delete<>': RuleHandler<FormattingCodeAny>;
-    'pod': RuleHandler<Para>;
-    'root': RuleHandler<RootBlock>;
+    pod: RuleHandler<Para>;
+    root: RuleHandler<RootBlock>;
     ':para': RuleHandler<Para>;
     ':text': RuleHandler<Text>;
     ':blankline': RuleHandler<BlankLine>;
@@ -39,33 +39,33 @@ export interface RulesStrict {
     ':list': RuleHandler<List>;
     ':config': RuleHandler<BlockConfig>;
     ':alias': RuleHandler<Alias>;
-    'data': RuleHandler<BlockData>;
-    'code': RuleHandler<BlockCode>;
-    'para': RuleHandler<BlockPara>;
-    'defn': RuleHandler<BlockDefn>;
-    'nested': RuleHandler<BlockNested>;
-    'output': RuleHandler<BlockOutput>;
-    'input': RuleHandler<BlockInput>;
-    'image': RuleHandler<BlockImage>;
+    data: RuleHandler<BlockData>;
+    code: RuleHandler<BlockCode>;
+    para: RuleHandler<BlockPara>;
+    defn: RuleHandler<BlockDefn>;
+    nested: RuleHandler<BlockNested>;
+    output: RuleHandler<BlockOutput>;
+    input: RuleHandler<BlockInput>;
+    image: RuleHandler<BlockImage>;
     ':image': RuleHandler<Image>;
     'item:block': RuleHandler<BlockItem>;
-    'item': RuleHandler<BlockItem>;
+    item: RuleHandler<BlockItem>;
     'comment:block': RuleHandler<BlockComment>;
-    'comment': RuleHandler<BlockComment>;
+    comment: RuleHandler<BlockComment>;
     'head:block': RuleHandler<BlockHead>;
-    'head': RuleHandler<BlockHead>;
+    head: RuleHandler<BlockHead>;
     ':fcode': RuleHandler<FormattingCodes>;
     'table:block': RuleHandler<BlockTable>;
-    'table': RuleHandler<BlockTable>;
+    table: RuleHandler<BlockTable>;
     ':separator': RuleHandler<Separator>;
-    'table_row': RuleHandler<TableRow>;
-    'table_cell': RuleHandler<TableCell>;
-    'table_head': RuleHandler<TableHead>;
+    table_row: RuleHandler<TableRow>;
+    table_cell: RuleHandler<TableCell>;
+    table_head: RuleHandler<TableHead>;
     ':toc': RuleHandler<Toc>;
     ':toc-list': RuleHandler<TocList>;
     ':toc-item': RuleHandler<TocItem>;
-    'Diagram': RuleHandler<BlockDiagram>;
-    'Image': RuleHandler<BlockNamed>;
+    Diagram: RuleHandler<BlockDiagram>;
+    Image: RuleHandler<BlockNamed>;
 }
 export interface Rules extends RulesStrict {
     [name: string]: RuleHandler;
@@ -114,112 +114,112 @@ export interface RootBlock extends Omit<Block, 'location'> {
     content: AstTree;
 }
 export interface FormattingCodeB {
-    type: "fcode";
-    name: "B";
+    type: 'fcode';
+    name: 'B';
     content?: Array<Node>;
 }
 export interface FormattingCodeC {
-    type: "fcode";
-    name: "C";
+    type: 'fcode';
+    name: 'C';
     content?: Array<FormattingCodes | string>;
 }
 export interface FormattingCodeE {
-    type: "fcode";
-    name: "E";
+    type: 'fcode';
+    name: 'E';
     content: Array<{
-        type: "number";
+        type: 'number';
         value: number;
     }>;
 }
 export interface FormattingCodeN {
-    type: "fcode";
-    name: "N";
+    type: 'fcode';
+    name: 'N';
     content?: Array<FormattingCodes | string>;
 }
 export interface FormattingCodeX {
-    type: "fcode";
-    name: "X";
+    type: 'fcode';
+    name: 'X';
     entry: Array<string> | null;
     content?: Array<FormattingCodes | string>;
 }
 export interface FormattingCodeZ {
-    type: "fcode";
-    name: "Z";
+    type: 'fcode';
+    name: 'Z';
     content?: string;
 }
 export interface FormattingCodeV {
-    type: "fcode";
-    name: "V";
+    type: 'fcode';
+    name: 'V';
     content?: string;
 }
 export interface FormattingCodeS {
-    type: "fcode";
-    name: "S";
+    type: 'fcode';
+    name: 'S';
     content?: string | Text;
 }
 export interface FormattingCodeA {
-    type: "fcode";
-    name: "A";
+    type: 'fcode';
+    name: 'A';
     content: string | Text;
 }
 export interface FormattingCodeD {
-    type: "fcode";
-    name: "D";
+    type: 'fcode';
+    name: 'D';
     synonyms: Array<string>;
     content: string;
 }
 export interface FormattingCodeL {
-    type: "fcode";
-    name: "L";
+    type: 'fcode';
+    name: 'L';
     meta: string | null;
     content: string | Text;
 }
 export interface FormattingCodeI {
-    type: "fcode";
-    name: "I";
+    type: 'fcode';
+    name: 'I';
     meta: string;
     content: string | Text;
 }
 export interface FormattingCodeAny {
-    type: "fcode";
+    type: 'fcode';
     name: string;
     content?: Array<FormattingCodes | string>;
 }
 export interface Ambient {
-    type: "ambient";
+    type: 'ambient';
     text: string;
     location: Location;
 }
 export interface Verbatim {
-    type: "verbatim";
+    type: 'verbatim';
     value: string;
 }
 export interface Text {
-    type: "text";
+    type: 'text';
     value: string;
 }
 export interface Para {
-    type: "para";
+    type: 'para';
     text: string;
     margin: string;
     location: Location;
     content: Array<Node | FormattingCodes>;
 }
 export interface Code {
-    type: "code";
+    type: 'code';
     text: string;
     margin: string;
     location: Location;
     content: Array<Verbatim | string>;
 }
 export interface BlankLine {
-    type: "blankline";
+    type: 'blankline';
 }
 export interface List {
-    type: "list";
+    type: 'list';
     level: string | number;
     content: Array<BlockItem | BlankLine | List>;
-    list: "itemized";
+    list: 'itemized';
 }
 export interface ConfigItemKV {
     [key: string]: string | number | boolean;
@@ -233,13 +233,13 @@ export interface ConfigItem {
 }
 export interface BlockConfig {
     name: string;
-    type: "config";
+    type: 'config';
     config: Array<ConfigItem>;
     margin: string;
 }
 export interface Alias {
     name: string;
-    type: "alias";
+    type: 'alias';
     replacement: Array<string>;
     margin: string;
 }
@@ -248,7 +248,7 @@ export interface Separator {
     text: string;
 }
 export interface Block {
-    type: "block";
+    type: 'block';
     location: Location;
     content: Array<Node>;
     margin: string;
@@ -268,18 +268,18 @@ export interface BlockDefn extends Block {
     name: 'defn';
 }
 export interface BlockItem extends Block {
-    name: "item";
+    name: 'item';
     content: Array<Node>;
     level: string | number;
 }
 export interface BlockOutput extends Block {
-    name: "output";
+    name: 'output';
 }
 export interface BlockInput extends Block {
-    name: "input";
+    name: 'input';
 }
 export interface BlockPara extends Block {
-    name: "para";
+    name: 'para';
 }
 export interface BlockCode extends Block {
     name: 'code';
@@ -292,28 +292,28 @@ export interface BlockHead extends Block {
     level: number | string;
 }
 export interface BlockTable extends Omit<Block, 'content'> {
-    name: "table";
+    name: 'table';
     content: Array<TableHead | TableSeparator | TableRow | BlankLine>;
     text?: string;
 }
 export interface TableCell {
-    name: "table_cell";
-    type: "block";
+    name: 'table_cell';
+    type: 'block';
     content: Array<string>;
 }
 export interface TableRow {
-    name: "table_row";
-    type: "block";
+    name: 'table_row';
+    type: 'block';
     content: Array<TableCell>;
 }
 export interface TableHead {
-    name: "table_head";
-    type: "block";
+    name: 'table_head';
+    type: 'block';
     content: Array<TableCell>;
 }
 export interface TableSeparator {
-    "type": "separator";
-    "text": string;
+    type: 'separator';
+    text: string;
 }
 export declare type BlockAny = BlockNamed;
 export interface BlockNamed extends Omit<Block, 'content'> {