@podlite/schema 0.0.55 → 0.0.56

package/lib/index.d.ts

@@ -1,8 +1,9 @@
 import { ErrorObject } from 'ajv';
-import { PodNode } from './types';
+import { ParseDiagnostic, PodNode } from './types';
 export { PodliteDocument } from './types';
 export { AstTree } from './types';
 export * from './types';
+export * from './block-names';
 export * from './blocks-helpers';
 export * from './query-helpers';
 export * from './ast-helpers';
@@ -68,6 +69,7 @@ export type parseOpt = {
     skipChain?: number;
     podMode?: number;
     mode?: 'pod' | 'md';
+    diagnostics?: ParseDiagnostic[];
 };
 declare function makeTree(): {
     (): void;

package/lib/index.js

@@ -50,9 +50,11 @@ exports.isValidateError = isValidateError;
 exports.toTree = makeTree;
 const ajv_1 = __importDefault(require("ajv"));
 const pointer = __importStar(require("json-pointer"));
+const block_names_1 = require("./block-names");
 const jsonShemes = __importStar(require("../schema"));
 const ast_inerator_1 = require("./ast-inerator");
 __exportStar(require("./types"), exports);
+__exportStar(require("./block-names"), exports);
 __exportStar(require("./blocks-helpers"), exports);
 __exportStar(require("./query-helpers"), exports);
 __exportStar(require("./ast-helpers"), exports);
@@ -187,8 +189,8 @@ function makeTree() {
         return chain;
     }
     function parse(src, opt = { skipChain: 0, podMode: 1 }) {
-        const { skipChain = 0, podMode = 1 } = opt;
-        let tree = parser.parse(src, { podMode });
+        const { skipChain = 0, podMode = 1, diagnostics } = opt;
+        let tree = parser.parse(src, { podMode, diagnostics, blockNames: block_names_1.BLOCK_NAMES });
         if (!skipChain) {
             for (let i = 0; i < plugins.length; i++) {
                 const plugin = plugins[i];

package/lib/pluggableParser.js

@@ -30,9 +30,18 @@ const podlitePluggable = ({ plugins = {} } = {}) => {
         return instance;
     };
     instance.parse = (text, opt = { skipChain: 0, podMode: 1 }) => {
-        const rawTree = (0, _1.toTree)().use(ids_1.default).parse(text, opt);
+        const diagnostics = opt.diagnostics || [];
+        const rawTree = (0, _1.toTree)()
+            .use(ids_1.default)
+            .parse(text, { ...opt, diagnostics });
+        // one mistake inside a value reports twice: for the value and for the whole
+        // attribute around it. The narrower report names the place to fix
+        const innermost = diagnostics.filter(d => !diagnostics.some(other => other !== d &&
+            other.location.start.offset >= d.location.start.offset &&
+            other.location.end.offset <= d.location.end.offset));
+        diagnostics.splice(0, diagnostics.length, ...innermost);
         const root = (0, _1.mkRootBlock)({ margin: '' }, rawTree);
-        return root;
+        return diagnostics.length ? { ...root, diagnostics } : root;
     };
     instance.toAst = ast => {
         return instance.toAstResult(ast).interator;

package/lib/plugin-items.js

@@ -1,5 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// At this point the leading content element is still an unparsed text node;
+// formatting codes are built from its value further down the pipeline. Cut the
+// marker out of that value and leave the node in place — replacing the array
+// with a plain string ends the chain early and drops every L<>, C<> and B< >
+// written on the same line.
+const stripMarker = (para, re) => {
+    para.text = para.text.replace(re, '');
+    if (para.type !== 'para')
+        return;
+    if (!Array.isArray(para.content)) {
+        para.content = [para.text];
+        return;
+    }
+    const first = para.content[0];
+    if (typeof first === 'string') {
+        para.content[0] = first.replace(re, '');
+    }
+    else if (first && typeof first.value === 'string') {
+        first.value = first.value.replace(re, '');
+    }
+};
 exports.default = () => tree => {
     const visit = node => {
         if (Array.isArray(node)) {
@@ -27,10 +48,7 @@ exports.default = () => tree => {
                                 const checkboxMatch = checkboxRe.exec(startText.text);
                                 if (checkboxMatch) {
                                     node.checked = checkboxMatch[1] === 'x';
-                                    startText.text = startText.text.replace(checkboxRe, '');
-                                    if (startText.type === 'para') {
-                                        startText.content = [startText.text];
-                                    }
+                                    stripMarker(startText, checkboxRe);
                                     node.config = node.config || [];
                                     node.config.push({
                                         name: 'checked',
@@ -42,10 +60,7 @@ exports.default = () => tree => {
                             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];
-                                }
+                                stripMarker(startText, re);
                                 node.config = node.config || [];
                                 node.config.push({
                                     name: 'numbered',

package/lib/types.d.ts

@@ -35,6 +35,7 @@ export interface RulesStrict {
     'X<>': RuleHandler<FormattingCodeX>;
     'S<>': RuleHandler<FormattingCodeS>;
     'L<>': RuleHandler<FormattingCodeL>;
+    'W<>': RuleHandler<FormattingCodeW>;
     'U<>': RuleHandler<FormattingCodeAny>;
     'Z<>': RuleHandler<FormattingCodeAny>;
     'O<>': RuleHandler<FormattingCodeAny>;
@@ -134,6 +135,13 @@ export interface BlockCaption extends Omit<Block, 'content' | 'location' | 'marg
 export interface RootBlock extends Omit<Block, 'location'> {
     name: 'root';
     content: AstTree;
+    diagnostics?: Array<ParseDiagnostic>;
+}
+export interface ParseDiagnostic {
+    severity: 'warning';
+    code: 'value-unreadable' | 'directive-unreadable';
+    message: string;
+    location: Location;
 }
 export interface FormattingCodeB {
     type: 'fcode';
@@ -210,6 +218,12 @@ export interface FormattingCodeL {
     meta: string | null;
     content: string | Text | [Text];
 }
+export interface FormattingCodeW {
+    type: 'fcode';
+    name: 'W';
+    meta: string | null;
+    content: string | Text | [Text];
+}
 export interface FormattingCodeI {
     type: 'fcode';
     name: 'I';
@@ -262,10 +276,11 @@ export interface ConfigItemKV {
 }
 export interface BrokenConfigItem extends Omit<ConfigItem, 'type'> {
 }
+export type ConfigItemType = 'boolean' | 'number' | 'string' | 'array' | 'map';
 export interface ConfigItem {
     name: string;
     value: boolean | string | number | Array<string | number | boolean> | ConfigItemKV;
-    type: string;
+    type: ConfigItemType;
     isFalse?: boolean;
 }
 export interface BlockConfig {
@@ -386,7 +401,7 @@ export interface BlockFormula extends Omit<BlockNamed, 'content'> {
     name: 'formula';
     content: [Verbatim];
 }
-export type FormattingCodes = FormattingCodeA | FormattingCodeC | FormattingCodeB | FormattingCodeD | FormattingCodeE | FormattingCodeF | FormattingCodeI | FormattingCodeL | FormattingCodeN | FormattingCodeX | FormattingCodeZ | FormattingCodeV | FormattingCodeS | FormattingCodeAny;
+export type FormattingCodes = FormattingCodeA | FormattingCodeC | FormattingCodeB | FormattingCodeD | FormattingCodeE | FormattingCodeF | FormattingCodeI | FormattingCodeL | FormattingCodeW | FormattingCodeN | FormattingCodeX | FormattingCodeZ | FormattingCodeV | FormattingCodeS | FormattingCodeAny;
 export type PodNode = Ambient | BlockPod | BlockData | BlockFormula | BlockCode | BlankLine | BlockNested | BlockMarkdown | BlockOutput | BlockInput | BlockInclude | BlockPara | BlockHead | BlockComment | BlockDefn | string | Para | Text | Code | BlockNamed | BlockAny | Verbatim | BlockTable | List | BlockConfig | BlockItem | Alias | BlockToc | BlockPicture | BlockImage | Image | RootBlock | Separator | BlockCaption | FormattingCodes | Toc;
 export type Node = PodNode;
 export type AstTree = Array<PodNode>;

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.0.55";
+export declare const version = "0.0.56";

package/lib/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // generated by scripts/inject-version.mjs — do not edit by hand
-exports.version = '0.0.55';
+exports.version = '0.0.56';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podlite/schema",
-  "version": "0.0.55",
+  "version": "0.0.56",
   "description": "AST tools and schema for Podlite markup language — validate, traverse, and transform document trees",
   "main": "./lib/index.js",
   "sideEffects": false,

package/schema/AstTree.json

@@ -123,6 +123,9 @@
                 {
                     "$ref": "#/definitions/FormattingCodeL"
                 },
+                {
+                    "$ref": "#/definitions/FormattingCodeW"
+                },
                 {
                     "$ref": "#/definitions/FormattingCodeN"
                 },
@@ -331,7 +334,7 @@
                     ]
                 },
                 "type": {
-                    "type": "string"
+                    "$ref": "#/definitions/ConfigItemType"
                 },
                 "isFalse": {
                     "type": "boolean"
@@ -343,6 +346,16 @@
                 "value"
             ]
         },
+        "ConfigItemType": {
+            "enum": [
+                "array",
+                "boolean",
+                "map",
+                "number",
+                "string"
+            ],
+            "type": "string"
+        },
         "BlockData": {
             "type": "object",
             "properties": {
@@ -1098,6 +1111,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -1279,6 +1295,12 @@
                 "content": {
                     "$ref": "#/definitions/AstTree"
                 },
+                "diagnostics": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/ParseDiagnostic"
+                    }
+                },
                 "margin": {
                     "type": "string"
                 },
@@ -1316,6 +1338,34 @@
                 "$ref": "#/definitions/PodNode"
             }
         },
+        "ParseDiagnostic": {
+            "type": "object",
+            "properties": {
+                "severity": {
+                    "type": "string",
+                    "const": "warning"
+                },
+                "code": {
+                    "enum": [
+                        "directive-unreadable",
+                        "value-unreadable"
+                    ],
+                    "type": "string"
+                },
+                "message": {
+                    "type": "string"
+                },
+                "location": {
+                    "$ref": "#/definitions/Location"
+                }
+            },
+            "required": [
+                "code",
+                "location",
+                "message",
+                "severity"
+            ]
+        },
         "Image": {
             "type": "object",
             "properties": {
@@ -1945,6 +1995,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -2213,6 +2266,51 @@
                 "type"
             ]
         },
+        "FormattingCodeW": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "type": "string",
+                    "const": "fcode"
+                },
+                "name": {
+                    "type": "string",
+                    "const": "W"
+                },
+                "meta": {
+                    "type": [
+                        "null",
+                        "string"
+                    ]
+                },
+                "content": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/definitions/Text"
+                        },
+                        {
+                            "type": "array",
+                            "items": [
+                                {
+                                    "$ref": "#/definitions/Text"
+                                }
+                            ],
+                            "minItems": 1,
+                            "maxItems": 1
+                        },
+                        {
+                            "type": "string"
+                        }
+                    ]
+                }
+            },
+            "required": [
+                "content",
+                "meta",
+                "name",
+                "type"
+            ]
+        },
         "FormattingCodeN": {
             "type": "object",
             "properties": {
@@ -2252,6 +2350,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -2334,6 +2435,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -2470,6 +2574,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },

package/schema/PodliteDocument.json

@@ -123,6 +123,9 @@
                 {
                     "$ref": "#/definitions/FormattingCodeL"
                 },
+                {
+                    "$ref": "#/definitions/FormattingCodeW"
+                },
                 {
                     "$ref": "#/definitions/FormattingCodeN"
                 },
@@ -331,7 +334,7 @@
                     ]
                 },
                 "type": {
-                    "type": "string"
+                    "$ref": "#/definitions/ConfigItemType"
                 },
                 "isFalse": {
                     "type": "boolean"
@@ -343,6 +346,16 @@
                 "value"
             ]
         },
+        "ConfigItemType": {
+            "enum": [
+                "array",
+                "boolean",
+                "map",
+                "number",
+                "string"
+            ],
+            "type": "string"
+        },
         "BlockData": {
             "type": "object",
             "properties": {
@@ -1098,6 +1111,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -1279,6 +1295,12 @@
                 "content": {
                     "$ref": "#/definitions/AstTree"
                 },
+                "diagnostics": {
+                    "type": "array",
+                    "items": {
+                        "$ref": "#/definitions/ParseDiagnostic"
+                    }
+                },
                 "margin": {
                     "type": "string"
                 },
@@ -1316,6 +1338,34 @@
                 "$ref": "#/definitions/PodNode"
             }
         },
+        "ParseDiagnostic": {
+            "type": "object",
+            "properties": {
+                "severity": {
+                    "type": "string",
+                    "const": "warning"
+                },
+                "code": {
+                    "enum": [
+                        "directive-unreadable",
+                        "value-unreadable"
+                    ],
+                    "type": "string"
+                },
+                "message": {
+                    "type": "string"
+                },
+                "location": {
+                    "$ref": "#/definitions/Location"
+                }
+            },
+            "required": [
+                "code",
+                "location",
+                "message",
+                "severity"
+            ]
+        },
         "Image": {
             "type": "object",
             "properties": {
@@ -1945,6 +1995,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -2213,6 +2266,51 @@
                 "type"
             ]
         },
+        "FormattingCodeW": {
+            "type": "object",
+            "properties": {
+                "type": {
+                    "type": "string",
+                    "const": "fcode"
+                },
+                "name": {
+                    "type": "string",
+                    "const": "W"
+                },
+                "meta": {
+                    "type": [
+                        "null",
+                        "string"
+                    ]
+                },
+                "content": {
+                    "anyOf": [
+                        {
+                            "$ref": "#/definitions/Text"
+                        },
+                        {
+                            "type": "array",
+                            "items": [
+                                {
+                                    "$ref": "#/definitions/Text"
+                                }
+                            ],
+                            "minItems": 1,
+                            "maxItems": 1
+                        },
+                        {
+                            "type": "string"
+                        }
+                    ]
+                }
+            },
+            "required": [
+                "content",
+                "meta",
+                "name",
+                "type"
+            ]
+        },
         "FormattingCodeN": {
             "type": "object",
             "properties": {
@@ -2252,6 +2350,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -2334,6 +2435,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },
@@ -2470,6 +2574,9 @@
                             {
                                 "$ref": "#/definitions/FormattingCodeL"
                             },
+                            {
+                                "$ref": "#/definitions/FormattingCodeW"
+                            },
                             {
                                 "$ref": "#/definitions/FormattingCodeN"
                             },