@podlite/schema 0.0.10 → 0.0.12

package/lib/helpers/config.d.ts

@@ -0,0 +1,12 @@
+export declare type Context = {
+    config?: any;
+};
+export interface Attr {
+    getAllValues: (name: any) => any;
+    getFirstValue: (name: any) => any;
+    asHash: () => {};
+    (): {};
+    exists(name: string): boolean;
+}
+export declare const makeAttrs: (node: any, ctx?: Context) => Attr;
+export default makeAttrs;

package/lib/helpers/config.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAttrs = void 0;
+const makeAttrs = (node, ctx = {}) => {
+    const config = node.config instanceof Array ? node.config : [];
+    // add config's from ctx
+    let configured = [];
+    if (ctx.config && ctx.config.hasOwnProperty(node.name)) {
+        configured = ctx.config[node.name];
+    }
+    let result = {};
+    [...config, ...configured].map(a => {
+        if (!result.hasOwnProperty(a.name)) {
+            result[a.name] = [];
+        }
+        if (a.type === 'array') {
+            result[a.name].push(...a.value);
+        }
+        else {
+            result[a.name].push(a.value);
+        }
+    });
+    let resfn = function () { };
+    /**
+     * check if prop exists
+     *
+     *  for example: attrs.exists('caption')
+     */
+    resfn.exists = (name) => result.hasOwnProperty(name);
+    /**
+     * return array for prop
+     *
+     *  for example: attrs.getAllValues('caption')
+     */
+    resfn.getAllValues = (name) => { return resfn.exists(name) ? result[name] : []; };
+    /**
+     * return first value or undefined if prop don't exists
+     *
+     *  for example: attrs.exists('caption')
+     */
+    resfn.getFirstValue = (name) => { return resfn.exists(name) ? resfn.getAllValues(name)[0] : undefined; };
+    /**
+     * return key: val
+     *
+     *  for example: attrs.asHash()
+     */
+    resfn.asHash = () => result;
+    return resfn;
+};
+exports.makeAttrs = makeAttrs;
+exports.default = exports.makeAttrs;

package/lib/helpers/handlers.d.ts

@@ -0,0 +1,47 @@
+import { RuleObject, RuleHandler } from './makeQuery';
+/**
+ * wrap content by open and closed tags
+ */
+export declare const wrapContent: (pre: any, post: any) => RuleHandler;
+/**
+ * emptyContent - skip any child node
+ */
+export declare const emptyContent: () => RuleHandler;
+/**
+ * content - process childs as regular content
+ */
+export declare const content: RuleHandler;
+/**
+
+Set hander after call with node
+
+':para':setFn((node,ctx) => (ctx.parents || [] ).includes('head') ? content : wrapContent('<p>','</p>'),
+
+*/
+export declare const setFn: (check: any) => RuleHandler;
+/**
+
+Set new context for handler
+
+        const parents = (ctx.parents || [])
+        parents.push('head')
+        const {level} = node
+        return setContext( { ...ctx, parents }, wrapContent(`<h${level}>`,`</h${level}>`))
+
+*/
+export declare const setContext: (ctx: any, fn: any) => RuleHandler;
+/**
+ * Make subset of rules for processing
+ *
+ * @param {*} rules
+ * @param {*} processNode
+ */
+export declare const subUse: (rules: RuleObject | Array<RuleObject>, processNode: any) => RuleHandler;
+/**
+ * Add support nesting
+ *
+ * @param {*} rules
+ * @param {*} implicitLevel - default level of nesting
+ *
+ */
+export declare const handleNested: (defaultHandler: RuleHandler, implicitLevel?: number) => RuleHandler;

package/lib/helpers/handlers.js

@@ -0,0 +1,119 @@
+"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;

package/lib/helpers/makeInterator.d.ts

@@ -0,0 +1,5 @@
+declare function thisFunc(rules: any): {
+    (node: any, context: any): any;
+    rules: any;
+};
+export default thisFunc;

package/lib/helpers/makeInterator.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function flattenDeep(arr) {
+    if (!Array.isArray(arr)) {
+        return arr;
+    }
+    return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
+}
+function thisFunc(rules) {
+    function interator(node, context) {
+        if (node instanceof Array) {
+            // filter null and undefined nodes
+            return flattenDeep(node.map(item => interator(item, context))).filter(Boolean);
+        }
+        if ('string' === typeof node) {
+            // convert string to lex node with type 
+            return interator({ type: 'text', value: node }, context);
+        }
+        // get first rule for this node
+        const reversed = rules.slice();
+        reversed.reverse();
+        const ruleIndex = reversed.findIndex(rule => rule.isFor(node));
+        if (ruleIndex !== -1) {
+            // try to find next rule
+            const nextRuleSet = reversed.slice(ruleIndex + 1);
+            const nextRuleIndex = nextRuleSet.findIndex(rule => rule.isFor(node));
+            const defaultFn = (n = node, ctx = context, localInterator = interator) => {
+                if (nextRuleIndex !== -1) {
+                    nextRuleSet[nextRuleIndex].fn(n, ctx, localInterator, () => { });
+                }
+                else {
+                    return;
+                }
+            };
+            if (typeof reversed[ruleIndex].fn !== 'function') {
+                console.warn('[pod6] bad fn for ' + JSON.stringify(node, null, 2));
+            }
+            return reversed[ruleIndex].fn(node, context, interator, defaultFn);
+        }
+        else {
+            // not found rule
+            const newNode = { ...node };
+            if (newNode.hasOwnProperty('content')) {
+                return interator(newNode.content, context);
+            }
+        }
+    }
+    interator.rules = rules;
+    return interator;
+}
+exports.default = thisFunc;

package/lib/helpers/makeQuery.d.ts

@@ -0,0 +1,47 @@
+import Writer from '../writer';
+/**
+sample      |  type        | name
+----------------------------------
+'C<>',
+'C:fcode'       fcode           C
+'<>'            fcode           any name, or /.+/
+'name'          block           'name'
+':blankline'    blankline       any name, or /.+/
+'C:fcode'       fcode           C
+'*:*', '*'      any type        any name
+
+*/
+export interface RuleHandler<T = any> {
+    (writer: Writer, processor: any): (node: T, ctx: any, interator: any) => void;
+}
+export declare type RuleObject = {
+    [name: string]: RuleHandler;
+};
+export declare type Filter = {
+    name: string;
+    type?: string;
+} | {
+    name?: any;
+    type: 'block' | any;
+} | {};
+export interface GetQuery {
+    (k: string): Filter;
+}
+export declare const makePlug: (k: string) => {};
+export declare function is(query: any, node: any): boolean;
+export interface Rule {
+    (): {};
+    isFor(): void;
+    fn(): void;
+}
+export declare const makeRule: (query: any, fn: any) => {
+    (): void;
+    rule: any;
+    isFor: (node: any) => boolean;
+    fn: any;
+};
+interface MakeRulesArray {
+    (key: RuleObject | Array<RuleObject>, fn?: Function): Array<any>;
+}
+export declare const makeRulesArray: MakeRulesArray;
+export {};

package/lib/helpers/makeQuery.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRulesArray = exports.makeRule = exports.is = exports.makePlug = void 0;
+const getQuery = function (k) {
+    if (k === '*:*' || k === '*') {
+        return {};
+    }
+    if (k === '<>') {
+        return { type: 'fcode' };
+    }
+    // try to split 'name:type'
+    let [name, type] = k.split(':');
+    if (name && type) {
+        return { name, type };
+    }
+    if (!name) {
+        return { type };
+    }
+    if (!type) {
+        // check C<>
+        const re = name.match(/(.+)\<\>/);
+        if (re) {
+            return { type: 'fcode', name: re[1] };
+        }
+        return { name, type: 'block' };
+    }
+    return { name, type };
+};
+const makePlug = (k) => {
+    const res = getQuery(k);
+    // @ts-ignores
+    let { name, type } = res;
+    if (type && type === '*') {
+        return { name };
+    }
+    if (name && name === '*') {
+        return { type };
+    }
+    return res;
+};
+exports.makePlug = makePlug;
+// is - check if node have handler
+function is(query, node) {
+    function isEmpty(obj) {
+        for (var prop in obj) {
+            if (obj.hasOwnProperty(prop))
+                return false;
+        }
+        return true;
+    }
+    // check if query empty
+    if (isEmpty(query))
+        return true;
+    for (var prop in query) {
+        if (query === undefined) {
+            console.warn('[pod6] undefined key!!!');
+        }
+        if (query.hasOwnProperty(prop)) {
+            if (node === undefined) {
+                console.warn('[pod6] undefined node!!!');
+            }
+            if (node && node.hasOwnProperty(prop)) {
+                if (query[prop] !== node[prop]) {
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.is = is;
+const makeRule = (query, fn) => {
+    rule.rule = query;
+    rule.isFor = isFor;
+    rule.fn = fn;
+    return rule;
+    function rule() { }
+    function isFor(node) {
+        if ('string' === typeof node)
+            return false;
+        return is(query, node);
+    }
+};
+exports.makeRule = makeRule;
+const makeRulesArray = (key, fn) => {
+    if (key instanceof Array) {
+        return key.reduce((acc, item) => { acc.push(...(0, exports.makeRulesArray)(item)); return acc; }, []);
+    }
+    if (key instanceof Object) {
+        let rules = [];
+        for (var prop in key) {
+            if (key.hasOwnProperty(prop)) {
+                rules.push((0, exports.makeRule)((0, exports.makePlug)(prop), key[prop]));
+            }
+        }
+        return rules;
+    }
+    return [(0, exports.makeRule)((0, exports.makePlug)(key), fn)];
+};
+exports.makeRulesArray = makeRulesArray;

package/lib/helpers/makeQuery.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/helpers/makeQuery.test.js

@@ -0,0 +1,41 @@
+const makePlug = require('./makeQuery').makePlug;
+const fixtures = [
+    'name:block', {
+        "name": "name",
+        "type": "block"
+    },
+    'C<>', {
+        'name': 'C',
+        'type': 'fcode'
+    },
+    ':blankline', {
+        'type': 'blankline'
+    },
+    '*:block', {
+        'type': 'block',
+    },
+    '*:*', {},
+    '*', {},
+    '<>', {
+        'type': 'fcode'
+    },
+    'name', {
+        'name': 'name',
+        'type': 'block'
+    },
+    'Special<>', {
+        'name': 'Special',
+        'type': 'fcode'
+    },
+];
+const pairs = fixtures.reduce(function (result, value, index, array) {
+    if (index % 2 === 0)
+        result.push(array.slice(index, index + 2));
+    return result;
+}, []);
+const log = (a) => console.log(JSON.stringify(a, null, 2));
+describe("run make query helpers tests", () => {
+    pairs.map(([k, v], idx) => {
+        test(`test ${idx}`, () => expect(makePlug(k)).toEqual(v));
+    });
+});

package/lib/helpers/makeTransformer.d.ts

@@ -0,0 +1,7 @@
+export declare function isNamedBlock(name: any): boolean;
+export declare function isSemanticBlock(node: any): boolean;
+export declare const makeTransformer: (rule: any) => {
+    (node: any, context?: any): any;
+    rules: any[];
+};
+export default makeTransformer;

package/lib/helpers/makeTransformer.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTransformer = exports.isSemanticBlock = exports.isNamedBlock = void 0;
+const { makeRule, makePlug } = require('./makeQuery');
+// the following names: MyBlock, myBlock are use for extending pod6
+function isNamedBlock(name) {
+    return (name
+        &&
+            name !== name.toLowerCase()
+        &&
+            name !== name.toUpperCase());
+}
+exports.isNamedBlock = isNamedBlock;
+// skip warnings for semantic blocks
+function isSemanticBlock(node) {
+    const name = node.name || '';
+    const isTypeBlock = (node.type || '') === 'block';
+    return isTypeBlock && name === name.toUpperCase();
+}
+exports.isSemanticBlock = isSemanticBlock;
+function flattenDeep(arr) {
+    return arr.reduce((acc, val) => Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
+}
+const makeTransformer = (rule) => {
+    let rules = [];
+    function use(key, fn) {
+        if (key instanceof Array) {
+            console.warn(`[pod] Unsupported param for ${key}`);
+        }
+        if (key instanceof Object) {
+            for (var prop in key) {
+                if (key.hasOwnProperty(prop)) {
+                    use(prop, key[prop]);
+                }
+            }
+            return [];
+        }
+        rules.push(makeRule(makePlug(key), fn));
+    }
+    function visiter(node, context = {}) {
+        if (node instanceof Array) {
+            return flattenDeep(node.map(item => visiter(item, context)));
+        }
+        if ('string' === typeof node) {
+            // convert string to lex node with type 
+            //return visiter({type:'text', value:node}, context)
+            return node;
+        }
+        // get first rule for this node
+        const reversed = rules.slice();
+        reversed.reverse();
+        const ruleIndex = reversed.findIndex(rule => rule.isFor(node));
+        if (ruleIndex !== -1) {
+            return reversed[ruleIndex].fn(node, context, visiter);
+        }
+        else {
+            // not found rule
+            const newNode = { ...node };
+            if (newNode.hasOwnProperty('content')) {
+                newNode.content = visiter(newNode.content, context);
+            }
+            return newNode;
+        }
+    }
+    use(rule);
+    visiter.rules = rules;
+    return visiter;
+};
+exports.makeTransformer = makeTransformer;
+exports.default = exports.makeTransformer;

package/lib/index.d.ts

@@ -5,7 +5,12 @@ export * from './types';
 export * from './blocks-helpers';
 export * from './query-helpers';
 export * from './ast-helpers';
+export * from './helpers/handlers';
 export { makeInterator } from './ast-inerator';
+export { makeTransformer, isNamedBlock, isSemanticBlock } from './helpers/makeTransformer';
+export { toAny } from './exportAny';
+export { makeAttrs } from './helpers/config';
+export { pluginCleanLocation } from './plugin-clean-location';
 export declare function toAst(): {};
 export declare type SchemaValidationError = ErrorObject<string, Record<string, any>>;
 export declare function getTextContentFromNode(node: PodNode): string;
@@ -16,3 +21,59 @@ export declare function isValidateError(result: SchemaValidationError[], src: an
 export interface Test {
     ters: string;
 }
+export interface nBlock {
+    "type": "block";
+    name: "pod";
+    content: AST;
+    margin: string;
+}
+export interface nCode {
+    "type": "code";
+    "content": [];
+    "name": string;
+    "margin": string;
+    "config": [];
+    "text": string;
+}
+export interface nText {
+    "type": "text";
+    "content": [];
+    "name": string;
+    "margin": string;
+    "config": [];
+    'value': string;
+}
+export interface nPara {
+    "type": "para";
+    "content": [];
+    "name": string;
+    "margin": string;
+    "config": [];
+}
+export interface nVerbatim {
+    type: 'verbatim';
+    value: string;
+    "margin": string;
+    "text": string;
+}
+export declare type Node = nBlock | nCode | nText | nPara | nVerbatim;
+export declare type AST = Array<Node>;
+export declare type ParserPlugin = (opt: {
+    skipChain: number;
+    podMode: number;
+}) => (param: AST) => AST;
+declare function makeTree(): {
+    (): void;
+    use: (plugin: ParserPlugin) => any;
+    parse: (src: string, opt?: {
+        skipChain: number;
+        podMode: number;
+    }) => AST;
+};
+export { makeTree as toTree };
+declare const parse: Function;
+export { parse as parse };
+export { default as toHtml } from './exportHtml';
+export { default as Writer } from './writer';
+declare const VERSION: any;
+export { VERSION as version };