@podlite/schema 0.0.3 → 0.0.7

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @podlite/schema
 
+## Upcoming
+## 0.0.7
+- add ast interator module (ast-inerator) 
+- add AST nodes for image and caption objects, add mkImage and mkCaption helpers 
+- add mkBlockItem, getTextContentFromNode and query blocks from AST helpers
+- add id prop to Node type
+- toc elements support
+## 0.0.6
+- list of supported schemas is explicit now
+- add support for create "blankline" blocks (mkBlankline)
+- enhance debug
+## 0.0.5
+- update deps
+## 0.0.4
+- fix npm package
+- add sometypes of blocks
+- update schema
+ 
 ## 0.0.3
 - update deps
 ## 0.0.2

package/lib/ast-helpers.d.ts

@@ -0,0 +1 @@
+export declare const getNodeId: (node: any, ctx: any) => any;

package/lib/ast-helpers.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeId = void 0;
+const config_1 = __importDefault(require("pod6/built/helpers/config"));
+const getNodeId = (node, ctx) => {
+    const conf = (0, config_1.default)(node, ctx);
+    if (conf.exists('id')) {
+        return conf.getFirstValue('id');
+    }
+    return node.id;
+};
+exports.getNodeId = getNodeId;

package/lib/ast-inerator.d.ts

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

package/lib/ast-inerator.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeInterator = exports.isSemanticBlock = exports.isNamedBlock = void 0;
+const { makeRule, makePlug } = require('pod6/built/helpers/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 makeInterator = (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.makeInterator = makeInterator;
+exports.default = exports.makeInterator;

package/lib/blocks-helpers.d.ts

@@ -0,0 +1,27 @@
+import { AstTree, BlockCaption, BlockItem, Location, PodNode, RootBlock, Toc, TocItem, TocList, Node, Image } from "./types";
+export declare const mkNode: <P extends Record<string, any>>(attr: P) => P;
+export declare const filterNulls: (content: any) => any[];
+export declare const mkBlock: (attrs: any, content: any) => any;
+export declare const mkBlankline: () => {
+    type: string;
+};
+export declare const mkFomattingCode: (attrs: any, content: any) => any;
+export declare const mkFomattingCodeL: (attrs: any, content: any) => any;
+export declare const mkVerbatim: (text: any) => {
+    type: string;
+    value: any;
+};
+export declare const mkToc: (content: TocList, title?: string) => Toc;
+export declare const mkTocList: (content: Array<TocItem | TocList>, level: number) => TocList;
+export declare const mkTocItem: (content: PodNode) => TocItem;
+export declare const mkCaption: (content: Array<Node>) => BlockCaption;
+export declare const mkImage: (src: string, alt?: string) => Image;
+export declare const mkRootBlock: ({ margin }: {
+    margin: any;
+}, content: any) => RootBlock;
+export interface mkBlockItemParams {
+    level: number;
+    location: Location;
+    margin: string;
+}
+export declare const mkItemBlock: ({ level, location, margin }: mkBlockItemParams, content: AstTree) => BlockItem;

package/lib/blocks-helpers.js

@@ -1,55 +1,75 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mkRootBlock = exports.mkBlockImage = exports.mkVerbatim = exports.mkFomattingCodeL = exports.mkFomattingCode = exports.mkBlock = exports.filterNulls = exports.mkNode = void 0;
-var mkNode = function (attr) {
-    return __assign({}, attr);
+exports.mkItemBlock = exports.mkRootBlock = exports.mkImage = exports.mkCaption = exports.mkTocItem = exports.mkTocList = exports.mkToc = exports.mkVerbatim = exports.mkFomattingCodeL = exports.mkFomattingCode = exports.mkBlankline = exports.mkBlock = exports.filterNulls = exports.mkNode = void 0;
+const nanoid_1 = require("nanoid");
+const mkNode = (attr) => {
+    return { ...attr };
 };
 exports.mkNode = mkNode;
-var filterNulls = function (content) {
+const filterNulls = (content) => {
     if (Array.isArray(content)) {
-        return content.filter(function (i) { return i; });
+        return content.filter(i => i);
     }
+    console.warn('[podlite-schema] filterNulls got not array as content');
 };
 exports.filterNulls = filterNulls;
-var mkBlock = function (attrs, content) {
-    var type = "block";
-    var name = attrs.name;
-    var attributres = __assign({}, attrs);
-    var result = exports.mkNode(__assign(__assign({ type: type }, attributres), { content: exports.filterNulls(content) }));
+const mkBlock = (attrs, content) => {
+    const type = "block";
+    const name = attrs.name;
+    const attributes = { id: (0, nanoid_1.nanoid)(), ...attrs };
+    var result = (0, exports.mkNode)({ type, ...attributes, content: (0, exports.filterNulls)(content) });
     return result;
 };
 exports.mkBlock = mkBlock;
-var mkFomattingCode = function (attrs, content) {
-    return exports.mkNode(__assign(__assign({ type: 'fcode' }, attrs), { content: content }));
+const mkBlankline = () => { return (0, exports.mkNode)({ type: 'blankline' }); };
+exports.mkBlankline = mkBlankline;
+const mkFomattingCode = (attrs, content) => {
+    return (0, exports.mkNode)({ type: 'fcode', ...attrs, content });
 };
 exports.mkFomattingCode = mkFomattingCode;
-var mkFomattingCodeL = function (attrs, content) {
-    var res = exports.mkNode(__assign(__assign({}, attrs), { type: 'fcode', name: "L", content: exports.filterNulls(content) }));
+const mkFomattingCodeL = (attrs, content) => {
+    let res = (0, exports.mkNode)({ ...attrs, type: 'fcode', name: "L", content: (0, exports.filterNulls)(content) });
     return res;
 };
 exports.mkFomattingCodeL = mkFomattingCodeL;
-var mkVerbatim = function (text) {
-    return exports.mkNode({ "type": "verbatim", "value": text });
+const mkVerbatim = (text) => {
+    return (0, exports.mkNode)({ "type": "verbatim", "value": text });
 };
 exports.mkVerbatim = mkVerbatim;
-var mkBlockImage = function (_a) {
-    var src = _a.src, alt = _a.alt, location = _a.location, margin = _a.margin;
-    return exports.mkBlock({ name: 'image', location: location, margin: margin }, [{ type: 'image', src: src, alt: alt }]);
+// Table of contents helpers
+const mkToc = (content, title) => {
+    return (0, exports.mkNode)({ type: 'toc', title, content });
+};
+exports.mkToc = mkToc;
+const mkTocList = (content, level) => {
+    return (0, exports.mkNode)({ type: 'toc-list', level, content });
 };
-exports.mkBlockImage = mkBlockImage;
-var mkRootBlock = function (_a, content) {
-    var margin = _a.margin;
-    return exports.mkBlock({ name: 'root', margin: margin }, content);
+exports.mkTocList = mkTocList;
+const mkTocItem = (content) => {
+    return (0, exports.mkNode)({ type: 'toc-item', node: content, content: [content] });
+};
+exports.mkTocItem = mkTocItem;
+const mkCaption = (content) => {
+    return {
+        type: 'block',
+        name: 'caption',
+        content
+    };
+};
+exports.mkCaption = mkCaption;
+const mkImage = (src, alt) => {
+    return {
+        type: 'image',
+        src,
+        alt
+    };
+};
+exports.mkImage = mkImage;
+const mkRootBlock = ({ margin }, content) => {
+    return (0, exports.mkBlock)({ name: 'root', margin }, content);
 };
 exports.mkRootBlock = mkRootBlock;
+const mkItemBlock = ({ level, location, margin }, content) => {
+    return (0, exports.mkBlock)({ name: 'item', level, margin, location }, content);
+};
+exports.mkItemBlock = mkItemBlock;

package/lib/helpers.d.ts

@@ -0,0 +1 @@
+export { wrapContent } from 'pod6/built/helpers/handlers';

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+import { ErrorObject } from 'ajv';
+import { PodNode } from './types';
+export { AstTree } from './types';
+export * from './types';
+export * from './blocks-helpers';
+export * from './query-helpers';
+export * from './ast-helpers';
+export { makeInterator } from './ast-inerator';
+export declare function toAst(): {};
+export declare type SchemaValidationError = ErrorObject<string, Record<string, any>>;
+export declare function getTextContentFromNode(node: PodNode): string;
+export declare function validatePodliteAst(data: unknown): SchemaValidationError[];
+export declare function validateAstTree(data: unknown): SchemaValidationError[];
+export declare function validateAst(data: unknown, Name?: string): SchemaValidationError[];
+export declare function isValidateError(result: SchemaValidationError[], src: any): any;
+export interface Test {
+    ters: string;
+}

package/lib/index.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
@@ -36,50 +25,47 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidateError = exports.validateAst = exports.validatePodliteAst = exports.getFromTree = exports.toAst = void 0;
-var ajv_1 = __importDefault(require("ajv"));
-var pointer = __importStar(require("json-pointer"));
-var makeTransformer_1 = __importDefault(require("pod6/built/helpers/makeTransformer"));
+exports.isValidateError = exports.validateAst = exports.validateAstTree = exports.validatePodliteAst = exports.getTextContentFromNode = exports.toAst = exports.makeInterator = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const pointer = __importStar(require("json-pointer"));
+const jsonShemes = __importStar(require("../schema"));
+const ast_inerator_1 = require("./ast-inerator");
 __exportStar(require("./types"), exports);
 __exportStar(require("./blocks-helpers"), exports);
+__exportStar(require("./query-helpers"), exports);
+__exportStar(require("./ast-helpers"), exports);
+var ast_inerator_2 = require("./ast-inerator");
+Object.defineProperty(exports, "makeInterator", { enumerable: true, get: function () { return ast_inerator_2.makeInterator; } });
 function toAst() {
     return {};
 }
 exports.toAst = toAst;
-var ajv = new ajv_1.default({ strict: true, allowUnionTypes: true });
-/**
- * Get nodes by queries
- * @param tree
- * @param queries
- * @returns array of matched nodes
- */
-var getFromTree = function (tree) {
-    var queries = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        queries[_i - 1] = arguments[_i];
-    }
-    var results = [];
-    var rules = {};
-    for (var _a = 0, queries_1 = queries; _a < queries_1.length; _a++) {
-        var rule = queries_1[_a];
-        rules[rule] = function (n, ctx, visiter) {
-            results.push(n);
-            if ('content' in n) {
-                return { n: n, content: transformer(n.content, __assign({}, ctx)) };
-            }
-        };
-    }
-    var transformer = makeTransformer_1.default(rules);
-    transformer(tree, {});
-    return results;
-};
-exports.getFromTree = getFromTree;
-function validatePodliteAst(data) { return validateAst(data, 'PodliteDocument.json'); }
+const ajv = new ajv_1.default({ strict: true, allowUnionTypes: true });
+function getTextContentFromNode(node) {
+    let text = '';
+    const rules = {
+        ":text": (node) => {
+            text += node.value;
+        },
+        ":verbatim": (node) => {
+            text += node.value;
+        },
+    };
+    const transformer = (0, ast_inerator_1.makeInterator)(rules);
+    const res = transformer(node, {});
+    return text;
+}
+exports.getTextContentFromNode = getTextContentFromNode;
+function validatePodliteAst(data) { return validateAst(data, 'PodliteDocument'); }
 exports.validatePodliteAst = validatePodliteAst;
-function validateAst(data, Name) {
-    if (Name === void 0) { Name = 'AstTree.json'; }
-    var AstTreeSchema = require("../schema/" + Name);
-    var validate = ajv.compile(AstTreeSchema);
+function validateAstTree(data) { return validateAst(data, 'AstTree'); }
+exports.validateAstTree = validateAstTree;
+function validateAst(data, Name = 'AstTree') {
+    const AstTreeSchema = jsonShemes[Name];
+    if (!AstTreeSchema) {
+        console.warn(`[validateAst] Can't exists ${Name} scheme.`);
+    }
+    const validate = ajv.compile(AstTreeSchema);
     if (validate(data)) {
         return [];
     }
@@ -89,13 +75,13 @@ exports.validateAst = validateAst;
 function isValidateError(result, src) {
     if (result.length > 0) {
         // get most erorred dataPath
-        var errors_by_path = {};
-        var reducer = function (acc, value) {
+        let errors_by_path = {};
+        const reducer = (acc, value) => {
             acc[value.dataPath] = (acc[value.dataPath] || 0) + 1;
             return acc;
         };
-        var pathMap_1 = result.reduce(reducer, errors_by_path);
-        var mostlyError = (Object.keys(pathMap_1).sort(function (a, b) { return pathMap_1[b] - pathMap_1[a]; }) || [])[0];
+        const pathMap = result.reduce(reducer, errors_by_path);
+        const mostlyError = (Object.keys(pathMap).sort((a, b) => pathMap[b] - pathMap[a]) || [])[0];
         return pointer.get(src, mostlyError);
     }
     return undefined;

package/lib/query-helpers.d.ts

@@ -0,0 +1,27 @@
+declare type Query = ((par: Object) => Boolean) | any;
+/**
+ * compileQuery - compile a query to a function
+    
+    Object as a parameter:
+    {'name':'head', level:[1,2,3,4]}
+    
+    const checkObject = compileQuery({name:'head',level:2}, (item)=>item.name === 1);
+    
+    Function as a parameter:
+    (item)=>item.name === 1
+    const checkObject2 = compileQuery((i)=>i.name == '1')
+
+    const r = checkObject([{name:'head', level:1},{name:'head', level:2},{name:'head', level:2}, {name:1, level:2}])
+ *
+ * @param obj
+ * @returns  function that can be used to filter the objects
+ */
+export declare const compileQuery: (...obj: Query[]) => (any: any) => any;
+/**
+ * Get nodes by queries
+ * @param tree
+ * @param queries
+ * @returns array of matched nodes
+ */
+export declare const getFromTree: (tree: any, ...queries: string[] | any) => any;
+export {};

package/lib/query-helpers.js

@@ -0,0 +1,133 @@
+"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"));
+/**
+ * compileQuery - compile a query to a function
+    
+    Object as a parameter:
+    {'name':'head', level:[1,2,3,4]}
+    
+    const checkObject = compileQuery({name:'head',level:2}, (item)=>item.name === 1);
+    
+    Function as a parameter:
+    (item)=>item.name === 1
+    const checkObject2 = compileQuery((i)=>i.name == '1')
+
+    const r = checkObject([{name:'head', level:1},{name:'head', level:2},{name:'head', level:2}, {name:1, level:2}])
+ *
+ * @param obj
+ * @returns  function that can be used to filter the objects
+ */
+const compileQuery = (...obj) => {
+    const queries = [];
+    const compiledQueries = obj.map(compileAtomQuery);
+    return function OR(par) {
+        const source = par instanceof Array ? par : [par];
+        const result = [];
+        source.forEach(item => {
+            if (item instanceof Array) {
+                result.push(...OR(item));
+            }
+            else {
+                // obj should accomplished if some queries is true
+                if (compiledQueries.some((fn) => fn(item).length > 0)) {
+                    result.push(item);
+                }
+            }
+        });
+        return result;
+    };
+};
+exports.compileQuery = compileQuery;
+const compileAtomQuery = (obj) => {
+    const queries = [];
+    if (obj instanceof Array) {
+        throw new Error("Wrong query parameter [Array], should be [Function] or [Object]");
+    }
+    else if (typeof obj === 'function') {
+        queries.push(obj);
+    }
+    else {
+        for (const entry of Object.entries(obj)) {
+            const [key, value] = entry;
+            const checkValue = (val) => {
+                if (value instanceof Array) {
+                    return value.includes(val);
+                }
+                else {
+                    if (typeof value === 'number') {
+                        return parseInt(val, 10) === value;
+                    }
+                    else {
+                        return val === value;
+                    }
+                }
+            };
+            const checkKeyfn = (obj) => {
+                if (obj.hasOwnProperty(key)) {
+                    return checkValue(obj[key]);
+                }
+                return false;
+            };
+            queries.push(checkKeyfn);
+        }
+    }
+    return function AND(obj) {
+        const source = obj instanceof Array ? obj : [obj];
+        const result = [];
+        source.forEach(item => {
+            if (item instanceof Array) {
+                result.push(...AND(item));
+            }
+            // obj should accomplished if all queries to be true
+            if (queries.every((fn) => fn(item))) {
+                result.push(item);
+            }
+        });
+        return result;
+    };
+};
+/**
+ * Get nodes by queries
+ * @param tree
+ * @param queries
+ * @returns array of matched nodes
+ */
+const getFromTree = (tree, ...queries) => {
+    if (!tree) {
+        return [];
+    }
+    let results = [];
+    let rules = {};
+    const transformer = (0, makeTransformer_1.default)({ '*:*': (node, ctx) => {
+            results.push(node);
+            if ('content' in node) {
+                return { node, content: transformer(node.content, { ...ctx }) };
+            }
+        } });
+    transformer(tree, {});
+    //convert queries
+    const queryAtoms = [];
+    queries.forEach(q => {
+        if (typeof q === 'string') {
+            const getNameLevel = q.match(/^(?<name>(item|head|.*))(?<level>(\d+)?)$/);
+            if (getNameLevel) {
+                let { name, level } = getNameLevel.groups;
+                if (name === 'item' && !level) {
+                    level = '1';
+                }
+                const levelNum = level ? parseInt(level, 10) : undefined;
+                queryAtoms.push({ name, ...(levelNum ? { level: levelNum } : {}) });
+            }
+        }
+        else {
+            queryAtoms.push(q);
+        }
+    });
+    return (0, exports.compileQuery)(...queryAtoms)(results);
+};
+exports.getFromTree = getFromTree;