@podlite/schema 0.0.11 → 0.0.13

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'> {

package/lib/types.js

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/writer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Default writer
+ */
+/// <reference types="node" />
+import * as Events from 'events';
+declare class Writer extends Events.EventEmitter {
+    INDEXTERMS: any[];
+    FOOTNOTES: any[];
+    output: any;
+    errors: any;
+    out: any;
+    ons: any[];
+    constructor(output?: any);
+    escape(p: any): any;
+    write(p: any): void;
+    writeRaw(str: any): void;
+    getStr(): {
+        errors: any;
+        toString: () => any;
+        valueOf: () => any;
+    };
+    startWrite(tree: any): void;
+    on(...params: any[]): this;
+    endWrite: () => void;
+    _add_nesting(n: number): void;
+    _remove_nesting(n: number): void;
+    addLevel(n: number): void;
+    removeLevel(n: number): void;
+}
+export default Writer;

package/lib/writer.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Default writer
+ */
+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]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Events = __importStar(require("events"));
+class Writer extends Events.EventEmitter {
+    INDEXTERMS;
+    FOOTNOTES;
+    output;
+    errors;
+    out;
+    ons;
+    // write: (p: any) => void;
+    // getStr: () => { errors: any; toString: () => any; valueOf: () => any; };
+    // errors: any;
+    // out: any;
+    // startWrite: () => void;
+    // ons: any[];
+    // endWrite: () => void;
+    constructor(output) {
+        super();
+        // save X<> entries
+        this.INDEXTERMS = [];
+        // save N<> annotates
+        this.FOOTNOTES = [];
+        this.output = output;
+        this.ons = [];
+        this.emit('ready');
+    }
+    // escape function for output
+    escape(p) {
+        return p;
+    }
+    // write with escape special symbols
+    write(p) {
+        return this.writeRaw(this.escape(p));
+    }
+    // raw write as is
+    writeRaw(str) {
+        if ('function' === typeof this.output) {
+            this.output(str);
+        }
+        else {
+            console.log(str);
+        }
+    }
+    getStr() {
+        return {
+            errors: this.errors,
+            toString: () => this.out,
+            valueOf: () => this.out,
+        };
+    }
+    startWrite(tree) {
+        // setup events
+        ;
+        (this.ons || []).map(a => 
+        //@ts-ignore
+        super.on(...a));
+        this.emit('start', tree);
+        this.addListener('errors', err => {
+            this.errors = this.errors || [];
+            this.errors.push(err);
+        });
+    }
+    on(...params) {
+        // overload 'on' method for reverse setup handlers
+        this.ons = this.ons || [];
+        this.ons.unshift([...params]);
+        return this;
+    }
+    endWrite = () => {
+        this.emit('end');
+    };
+    // nesting methods
+    _add_nesting(n) { }
+    _remove_nesting(n) { }
+    addLevel(n) {
+        this._add_nesting(n);
+    }
+    removeLevel(n) {
+        this._remove_nesting(n);
+    }
+}
+exports.default = Writer;
+//# sourceMappingURL=writer.js.map

package/lib/writerHtml.d.ts

@@ -0,0 +1,11 @@
+/**
+ * HTML writer
+ */
+import Writer from './writer';
+declare class WriterHTML extends Writer {
+    constructor(output?: any);
+    escape(string: any): string;
+    _add_nesting(n: any): void;
+    _remove_nesting(n: any): void;
+}
+export default WriterHTML;

package/lib/writerHtml.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * HTML writer
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const writer_1 = __importDefault(require("./writer"));
+class WriterHTML extends writer_1.default {
+    constructor(output) {
+        super(output);
+    }
+    escape(string) {
+        const HTML_CHARS = {
+            '&': '&',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            "'": '&#x27;',
+            '/': '&#x2F;',
+            '`': '&#x60;',
+        };
+        return (string + '').replace(/[&<>"'\/`]/g, match => HTML_CHARS[match]);
+    }
+    _add_nesting(n) {
+        this.writeRaw('<blockquote>'.repeat(n));
+    }
+    _remove_nesting(n) {
+        this.writeRaw('</blockquote>'.repeat(n));
+    }
+}
+exports.default = WriterHTML;
+//# sourceMappingURL=writerHtml.js.map

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@podlite/schema",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "podlite schema",
-  "main": "index.js",
+  "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "MIT",
   "files": [
@@ -18,30 +18,38 @@
   "engineStrict": true,
   "publishConfig": {
     "access": "public",
-    "main": "index.js",
-    "module": "index.js",
+    "main": "lib/index.js",
     "types": "./lib/index.d.ts"
   },
   "scripts": {
-    "clean": "rm -rf lib tsconfig.tsbuildinfo",
-    "build": "run-s build:ts build:ast",
+    "clean": "rm -rf lib esm tsconfig.tsbuildinfo",
+    "build": "run-s build:pegjs build:ts build:ast ",
     "build:ast": "ts-node scripts/make-ast-scheme.ts",
     "build:ts": "yarn g:tsc --build $INIT_CWD",
+    "build:esm": "yarn g:tsctest -p tsconfig.esm.json",
+    "build:pegjs": "pegjs -o src/grammar.js src/grammar.pegjs && pegjs -o src/grammarfc.js src/grammarfc.pegjs",
     "watch": "npx nodemon -e js,ts --exec 'yarn' build",
     "test": "yarn g:jest  --passWithNoTests"
   },
+  "keywords": [
+    "markdown",
+    "podlite",
+    "markup",
+    "markup-language"
+  ],
   "dependencies": {
     "ajv": "^7.2.3",
+    "events": "^3.1.0",
     "json-pointer": "^0.6.1",
-    "nanoid": "3.1.30",
-    "pod6": "^0.0.48"
+    "nanoid": "3.1.30"
   },
   "devDependencies": {
     "@types/node": "^17.0.7",
     "glob": "^7.2.0",
+    "npm-run-all": "^4.1.5",
+    "pegjs": "^0.10.0",
     "ts-node": "^9.1.1",
     "typescript": "4.5.5",
     "typescript-json-schema": "0.53.0"
-  },
-  "module": "index.js"
+  }
 }

package/schema/index.d.ts

@@ -1,3 +1,3 @@
-export var Test: any;
-export var AstTree: any;
-export var PodliteDocument: any;
+export var Test: any
+export var AstTree: any
+export var PodliteDocument: any

package/index.js

@@ -1,2 +0,0 @@
-'use strict'
-module.exports = require('./lib')

package/lib/helpers.d.ts

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

package/lib/helpers.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapContent = void 0;
-var handlers_1 = require("pod6/built/helpers/handlers");
-Object.defineProperty(exports, "wrapContent", { enumerable: true, get: function () { return handlers_1.wrapContent; } });