@podlite/schema 0.0.11 → 0.0.13

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,56 @@
+"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;
+//# sourceMappingURL=config.js.map

package/lib/helpers/corePlugins.d.ts

@@ -0,0 +1,12 @@
+export declare const core: {
+    ':image': {
+        toHtml: (writer: any) => (node: any) => void;
+    };
+    image: {
+        toHtml: import("./makeQuery").RuleHandler<any>;
+    };
+    root: {
+        toHtml: import("./makeQuery").RuleHandler<any>;
+    };
+};
+export default core;

package/lib/helpers/corePlugins.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.core = void 0;
+const __1 = require("..");
+exports.core = {
+    ':image': {
+        toHtml: writer => node => {
+            if (typeof node !== 'string' && 'type' in node && node.type === 'image') {
+                writer.writeRaw(`<img`);
+                writer.writeRaw(` src="${node.src}"`);
+                if (node.alt) {
+                    writer.writeRaw(` alt="${node.alt}"`);
+                }
+                writer.writeRaw(`/>`);
+            }
+        },
+    },
+    image: {
+        toHtml: __1.content,
+    },
+    root: {
+        toHtml: __1.content,
+    },
+};
+exports.default = exports.core;
+//# sourceMappingURL=corePlugins.js.map

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,120 @@
+"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;
+//# sourceMappingURL=handlers.js.map

package/lib/helpers/ids.d.ts

@@ -0,0 +1,18 @@
+import { ParserPlugin } from '..';
+/**
+ * Clean ids from tree
+ * @returns
+ */
+export declare const cleanIds: (src?: {
+    skipChain: number;
+    podMode: number;
+}) => (tree: any) => any;
+/**
+ * Add set id to 'id' to each blocks
+ */
+export declare const frozenIds: (src?: {
+    skipChain: number;
+    podMode: number;
+}) => (tree: any) => any;
+declare const middleware: ParserPlugin;
+export default middleware;

package/lib/helpers/ids.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frozenIds = exports.cleanIds = void 0;
+const __1 = require("..");
+const nanoid_1 = require("nanoid");
+/**
+ * Clean ids from tree
+ * @returns
+ */
+const cleanIds = (src = { skipChain: 0, podMode: 1 }) => tree => {
+    const transformerBlocks = (0, __1.makeTransformer)({
+        '*': (node, ctx, visiter) => {
+            if ('id' in node) {
+                if ('content' in node) {
+                    node.content = visiter(node.content, ctx);
+                }
+                const { id, ...rest } = node;
+                return { ...rest };
+            }
+            return node;
+        },
+    });
+    return transformerBlocks(tree, {});
+};
+exports.cleanIds = cleanIds;
+/**
+ * Add set id to 'id' to each blocks
+ */
+const frozenIds = (src = { skipChain: 0, podMode: 1 }) => tree => {
+    const transformerBlocks = (0, __1.makeTransformer)({
+        '*': (node, ctx, visiter) => {
+            if ('id' in node) {
+                if ('content' in node) {
+                    node.content = visiter(node.content, ctx);
+                }
+                const { id, ...rest } = node;
+                return { ...rest, id: 'id' };
+            }
+            return node;
+        },
+    });
+    return transformerBlocks(tree, {});
+};
+exports.frozenIds = frozenIds;
+const middleware = () => tree => {
+    const transformerBlocks = (0, __1.makeTransformer)({
+        '*': (node, ctx, visiter) => {
+            const addIdField = (node) => {
+                if (typeof node === 'object' && 'type' in node && node.type == 'block') {
+                    if (node.name == 'caption') {
+                        return node;
+                    }
+                    else if (node.name == 'head') {
+                        return { ...node, id: (0, __1.getTextContentFromNode)(node).trim() };
+                    }
+                    else {
+                        return { ...node, id: (0, nanoid_1.nanoid)() };
+                    }
+                }
+                return node;
+            };
+            const processContent = (node) => {
+                if (typeof node === 'object' && 'content' in node) {
+                    return { ...node, content: visiter(node.content, ctx) };
+                }
+                return node;
+            };
+            return processContent(addIdField(node));
+        },
+    });
+    return transformerBlocks(tree, {});
+};
+exports.default = middleware;
+//# sourceMappingURL=ids.js.map

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,54 @@
+"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, () => {
+                        /* empty default action */
+                    });
+                }
+                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;
+//# sourceMappingURL=makeInterator.js.map

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,107 @@
+"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;
+//# sourceMappingURL=makeQuery.js.map

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

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

package/lib/helpers/makeQuery.test.js

@@ -0,0 +1,51 @@
+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));
+    });
+});
+//# sourceMappingURL=makeQuery.test.js.map

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;