db-modeling-markdown 2.0.1 → 2.1.0

package/dist/lib/markdown-object/markdownReader.d.ts

@@ -1,39 +1,39 @@
-declare type ObjectValueType = null | string | number | boolean;
-/**
- * Main functions:
- * read a markdown file into an object
- */
-export declare class MarkdownReader {
-    path: string;
-    constructor(path: string);
-    private static createHeader;
-    private static createListItem;
-    private static handleHeader;
-    private static handleList;
-    private static handleTable;
-    private static isArrayTable;
-    private static mergeTableRow;
-    static normalize(value: string, isPropertyName?: boolean): ObjectValueType;
-    private static normalizeTableRow;
-    private static readLine;
-    toObject(): any;
-    /**
-     * convert the markdown object to the model object
-     * @param table the markdown object
-     * @returns the dbTable object
-     */
-    private static upgrade;
-    /**
-     * Version 1
-     * @param table the markdown object
-     * @returns the dbTable object
-     */
-    private static upgradeV1;
-    /**
-     * Version 2
-     * @param table the markdown object
-     * @returns the dbTable object
-     */
-    private static upgradeV2;
-}
-export {};
+type ObjectValueType = null | string | number | boolean;
+/**
+ * Main functions:
+ * read a markdown file into an object
+ */
+export declare class MarkdownReader {
+    path: string;
+    constructor(path: string);
+    private static createHeader;
+    private static createListItem;
+    private static handleHeader;
+    private static handleList;
+    private static handleTable;
+    private static isArrayTable;
+    private static mergeTableRow;
+    static normalize(value: string, isPropertyName?: boolean): ObjectValueType;
+    private static normalizeTableRow;
+    private static readLine;
+    toObject(): any;
+    /**
+     * convert the markdown object to the model object
+     * @param table the markdown object
+     * @returns the dbTable object
+     */
+    private static upgrade;
+    /**
+     * Version 1
+     * @param table the markdown object
+     * @returns the dbTable object
+     */
+    private static upgradeV1;
+    /**
+     * Version 2
+     * @param table the markdown object
+     * @returns the dbTable object
+     */
+    private static upgradeV2;
+}
+export {};

package/dist/lib/markdown-object/markdownReader.js

@@ -1,259 +1,262 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MarkdownReader = void 0;
-const markdownParser_1 = require("../utils/markdownParser");
-const textFileReader_1 = require("../utils/textFileReader");
-const textHelper_1 = require("../utils/textHelper");
-const markdownModel_1 = require("./markdownModel");
-const readerContext_1 = require("./readerContext");
-/**
- * Main functions:
- * read a markdown file into an object
- */
-class MarkdownReader {
-    constructor(path) {
-        this.path = path;
-    }
-    static createHeader(array, context) {
-        const element = {
-            type: markdownModel_1.MarkdownElementType.header,
-            level: array[1].length,
-            name: array[2],
-        };
-        if (element.level <= 1) {
-            return;
-        }
-        if (element.level <= context.currentLevel) {
-            context.pop(element.level - 1);
-        }
-        let propertyName = MarkdownReader.normalize(element.name, true);
-        // case: the property is an array
-        if (propertyName.endsWith('[]')) {
-            propertyName = propertyName.substring(0, propertyName.length - 2).trim();
-        }
-        // generate the property
-        context.push(propertyName, null);
-    }
-    static createListItem(array, context) {
-        const element = {
-            type: markdownModel_1.MarkdownElementType.listItem,
-            level: 0,
-            name: array[1],
-            value: array[2],
-        };
-        // TODO: case: multiple lines value
-        context.setCurrentProperty(MarkdownReader.normalize(element.name, true), MarkdownReader.normalize(element.value));
-    }
-    static handleHeader(line, reader, context) {
-        if (!line) {
-            return true;
-        }
-        const result = markdownParser_1.MarkdownParser.matchHeader(line);
-        if (result) {
-            MarkdownReader.createHeader(result, context);
-            return true;
-        }
-        return false;
-    }
-    static handleList(line, reader, context) {
-        if (!line) {
-            return true;
-        }
-        const result = markdownParser_1.MarkdownParser.matchListItem(line);
-        if (result) {
-            MarkdownReader.createListItem(result, context);
-            return true;
-        }
-        return false;
-    }
-    static handleTable(line, reader, context) {
-        if (!line) {
-            // case: end of file
-            return true;
-        }
-        let isValid = markdownParser_1.MarkdownParser.testTableHeader(line);
-        if (!isValid) {
-            return false;
-        }
-        // check if the next line is table line row
-        const headerLine = line;
-        let dataLine = reader.peak();
-        if (!dataLine) {
-            // case: end of file
-            return true;
-        }
-        isValid = markdownParser_1.MarkdownParser.testTableLine(dataLine);
-        if (!isValid) {
-            return false;
-        }
-        reader.move();
-        context.current = [];
-        const headers = MarkdownReader.normalizeTableRow(headerLine, true);
-        const isArray = MarkdownReader.isArrayTable(headers);
-        // now: it is a table, read table rows
-        while (reader.hasMore(1)) {
-            dataLine = reader.peak().trim();
-            if (!dataLine) {
-                // case: end of file
-                return true;
-            }
-            isValid = markdownParser_1.MarkdownParser.testTableRow(dataLine);
-            if (!isValid) {
-                // true: indicate we use these read lines
-                return true;
-            }
-            reader.move();
-            // read a data row
-            const cells = MarkdownReader.normalizeTableRow(dataLine);
-            if (isArray) {
-                if (!context.current) {
-                    context.current = [];
-                }
-                context.current.push(cells);
-            }
-            else {
-                // data row -> data row object
-                const rowObject = {};
-                headers.some((header, index) => {
-                    if (index >= cells.length) {
-                        return true;
-                    }
-                    rowObject[header] = cells[index];
-                    return false;
-                });
-                // put into the result
-                if (!MarkdownReader.mergeTableRow(headers, rowObject, context)) {
-                    context.current.push(rowObject);
-                }
-            }
-        }
-        return false;
-    }
-    static isArrayTable(headers) {
-        for (let i = 0; i < headers.length; i += 1) {
-            if (headers[i].length > 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-    static mergeTableRow(headers, rowObject, context) {
-        if (context.current.length === 0 || rowObject[headers[0]] !== '' || rowObject[headers[1]] !== '') {
-            return false;
-        }
-        const lastObject = context.current[context.current.length - 1];
-        headers.forEach((header) => {
-            const prop = rowObject[header];
-            if (prop) {
-                // TODO: merge with \r\n
-                lastObject[header] = `${lastObject[header]} ${prop}`;
-            }
-        });
-        return true;
-    }
-    static normalize(value, isPropertyName = false) {
-        if (!value) {
-            return value;
-        }
-        let newValue = textHelper_1.TextHelper.decodeMarkdown(value.trim());
-        // case: inline code
-        if (newValue.length >= 2 && newValue[0] === '`' && newValue[newValue.length - 1] === '`') {
-            const blockValue = newValue.substring(1, newValue.length - 1);
-            if (!isPropertyName) {
-                if (blockValue.toLocaleLowerCase() === 'yes' || blockValue.toLocaleLowerCase() === 'true') {
-                    newValue = true;
-                }
-                else if (blockValue.toLocaleLowerCase() === 'no' || blockValue.toLocaleLowerCase() === 'false') {
-                    newValue = false;
-                }
-                else if (blockValue.toLocaleLowerCase() === 'null') {
-                    newValue = null;
-                }
-                else {
-                    const testValue = parseFloat(blockValue);
-                    // eslint-disable-next-line no-restricted-globals
-                    if (!isNaN(testValue)) {
-                        newValue = testValue;
-                    }
-                }
-            }
-            else {
-                newValue = newValue.substring(1, newValue.length - 1);
-            }
-        }
-        // case: produce a good property name
-        if (isPropertyName && typeof newValue === 'string' && newValue.length > 0) {
-            // case: remove spaces
-            newValue = newValue.replace(' ', '');
-            // case: camelCase
-            newValue = newValue[0].toLocaleLowerCase() + newValue.substr(1, newValue.length);
-        }
-        return newValue;
-    }
-    static normalizeTableRow(line, isName = false) {
-        const values = markdownParser_1.MarkdownParser.splitTableRowToCells(line);
-        return values.map((value) => MarkdownReader.normalize(value, isName));
-    }
-    static readLine(line, reader, context) {
-        if (MarkdownReader.handleHeader(line, reader, context)) {
-            return;
-        }
-        if (MarkdownReader.handleList(line, reader, context)) {
-            return;
-        }
-        MarkdownReader.handleTable(line, reader, context);
-    }
-    toObject() {
-        const reader = new textFileReader_1.TextFileReader();
-        const context = new readerContext_1.ReadContext();
-        reader.open(this.path);
-        while (reader.hasMore()) {
-            MarkdownReader.readLine(reader.read().trim(), reader, context);
-        }
-        return MarkdownReader.upgrade(context.root);
-    }
-    /**
-     * convert the markdown object to the model object
-     * @param table the markdown object
-     * @returns the dbTable object
-     */
-    static upgrade(table) {
-        if (table.name) {
-            return MarkdownReader.upgradeV1(table);
-        }
-        return MarkdownReader.upgradeV2(table);
-    }
-    /**
-     * Version 1
-     * @param table the markdown object
-     * @returns the dbTable object
-     */
-    static upgradeV1(table) {
-        return {
-            name: table.name,
-            comment: table.comment,
-            primaryKey: table.primaryKey,
-            indexes: table.indexes || [],
-            foreignKeys: table.foreignKeys || [],
-            columns: table.columns || [],
-        };
-    }
-    /**
-     * Version 2
-     * @param table the markdown object
-     * @returns the dbTable object
-     */
-    static upgradeV2(table) {
-        const basic = table.table && table.table.length > 0 ? table.table[0] : undefined;
-        return {
-            name: basic?.name,
-            comment: basic?.comment,
-            primaryKey: table.primaryKey?.length > 0 ? table.primaryKey[0] : undefined,
-            indexes: table.indexes || [],
-            foreignKeys: table.foreignKeys || [],
-            columns: table.columns || [],
-        };
-    }
-}
-exports.MarkdownReader = MarkdownReader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownReader = void 0;
+/* eslint-disable no-restricted-syntax */
+const markdownParser_1 = require("../utils/markdownParser");
+const textFileReader_1 = require("../utils/textFileReader");
+const textHelper_1 = require("../utils/textHelper");
+const markdownModel_1 = require("./markdownModel");
+const readerContext_1 = require("./readerContext");
+/**
+ * Main functions:
+ * read a markdown file into an object
+ */
+class MarkdownReader {
+    constructor(path) {
+        this.path = path;
+    }
+    static createHeader(array, context) {
+        const element = {
+            type: markdownModel_1.MarkdownElementType.header,
+            level: array[1].length,
+            name: array[2],
+        };
+        if (element.level <= 1) {
+            return;
+        }
+        if (element.level <= context.currentLevel) {
+            context.pop(element.level - 1);
+        }
+        let propertyName = MarkdownReader.normalize(element.name, true);
+        // case: the property is an array
+        if (propertyName.endsWith('[]')) {
+            propertyName = propertyName.substring(0, propertyName.length - 2).trim();
+        }
+        // generate the property
+        context.push(propertyName, null);
+    }
+    static createListItem(array, context) {
+        const element = {
+            type: markdownModel_1.MarkdownElementType.listItem,
+            level: 0,
+            name: array[1],
+            value: array[2],
+        };
+        // TODO: case: multiple lines value
+        context.setCurrentProperty(MarkdownReader.normalize(element.name, true), MarkdownReader.normalize(element.value));
+    }
+    static handleHeader(line, reader, context) {
+        if (!line) {
+            return true;
+        }
+        const result = markdownParser_1.MarkdownParser.matchHeader(line);
+        if (result) {
+            MarkdownReader.createHeader(result, context);
+            return true;
+        }
+        return false;
+    }
+    static handleList(line, reader, context) {
+        if (!line) {
+            return true;
+        }
+        const result = markdownParser_1.MarkdownParser.matchListItem(line);
+        if (result) {
+            MarkdownReader.createListItem(result, context);
+            return true;
+        }
+        return false;
+    }
+    static handleTable(line, reader, context) {
+        if (!line) {
+            // case: end of file
+            return true;
+        }
+        let isValid = markdownParser_1.MarkdownParser.testTableHeader(line);
+        if (!isValid) {
+            return false;
+        }
+        // check if the next line is table line row
+        const headerLine = line;
+        let dataLine = reader.peak();
+        if (!dataLine) {
+            // case: end of file
+            return true;
+        }
+        isValid = markdownParser_1.MarkdownParser.testTableLine(dataLine);
+        if (!isValid) {
+            return false;
+        }
+        reader.move();
+        context.current = [];
+        const headers = MarkdownReader.normalizeTableRow(headerLine, true);
+        const isArray = MarkdownReader.isArrayTable(headers);
+        // now: it is a table, read table rows
+        while (reader.hasMore(1)) {
+            dataLine = reader.peak().trim();
+            if (!dataLine) {
+                // case: end of file
+                return true;
+            }
+            isValid = markdownParser_1.MarkdownParser.testTableRow(dataLine);
+            if (!isValid) {
+                // true: indicate we use these read lines
+                return true;
+            }
+            reader.move();
+            // read a data row
+            const cells = MarkdownReader.normalizeTableRow(dataLine);
+            if (isArray) {
+                if (!context.current) {
+                    context.current = [];
+                }
+                context.current.push(cells);
+            }
+            else {
+                // data row -> data row object
+                const rowObject = {};
+                headers.some((header, index) => {
+                    if (index >= cells.length) {
+                        return true;
+                    }
+                    rowObject[header] = cells[index];
+                    return false;
+                });
+                // put into the result
+                if (!MarkdownReader.mergeTableRow(headers, rowObject, context)) {
+                    context.current.push(rowObject);
+                }
+            }
+        }
+        return false;
+    }
+    static isArrayTable(headers) {
+        for (const element of headers) {
+            if (element.length > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static mergeTableRow(headers, rowObject, context) {
+        if (context.current.length === 0 ||
+            rowObject[headers[0]] !== '' ||
+            rowObject[headers[1]] !== '') {
+            return false;
+        }
+        const lastObject = context.current[context.current.length - 1];
+        headers.forEach((header) => {
+            const prop = rowObject[header];
+            if (prop) {
+                // TODO: merge with \r\n
+                lastObject[header] = `${lastObject[header]} ${prop}`;
+            }
+        });
+        return true;
+    }
+    static normalize(value, isPropertyName = false) {
+        if (!value) {
+            return value;
+        }
+        let newValue = textHelper_1.TextHelper.decodeMarkdown(value.trim());
+        // case: inline code
+        if (newValue.length >= 2 && newValue[0] === '`' && newValue[newValue.length - 1] === '`') {
+            const blockValue = newValue.substring(1, newValue.length - 1);
+            if (!isPropertyName) {
+                const lowerValue = blockValue.toLocaleLowerCase();
+                if (lowerValue === 'yes' || lowerValue === 'true') {
+                    newValue = true;
+                }
+                else if (lowerValue === 'no' || lowerValue === 'false') {
+                    newValue = false;
+                }
+                else if (lowerValue === 'null') {
+                    newValue = null;
+                }
+                else {
+                    const testValue = parseFloat(blockValue);
+                    // eslint-disable-next-line no-restricted-globals
+                    if (!isNaN(testValue)) {
+                        newValue = testValue;
+                    }
+                }
+            }
+            else {
+                newValue = newValue.substring(1, newValue.length - 1);
+            }
+        }
+        // case: produce a good property name
+        if (isPropertyName && typeof newValue === 'string' && newValue.length > 0) {
+            // case: remove spaces
+            newValue = newValue.replace(' ', '');
+            // case: camelCase
+            newValue = newValue[0].toLocaleLowerCase() + newValue.substr(1, newValue.length);
+        }
+        return newValue;
+    }
+    static normalizeTableRow(line, isName = false) {
+        const values = markdownParser_1.MarkdownParser.splitTableRowToCells(line);
+        return values.map((value) => MarkdownReader.normalize(value, isName));
+    }
+    static readLine(line, reader, context) {
+        if (MarkdownReader.handleHeader(line, reader, context)) {
+            return;
+        }
+        if (MarkdownReader.handleList(line, reader, context)) {
+            return;
+        }
+        MarkdownReader.handleTable(line, reader, context);
+    }
+    toObject() {
+        const reader = new textFileReader_1.TextFileReader();
+        const context = new readerContext_1.ReadContext();
+        reader.open(this.path);
+        while (reader.hasMore()) {
+            MarkdownReader.readLine(reader.read().trim(), reader, context);
+        }
+        return MarkdownReader.upgrade(context.root);
+    }
+    /**
+     * convert the markdown object to the model object
+     * @param table the markdown object
+     * @returns the dbTable object
+     */
+    static upgrade(table) {
+        if (table.name) {
+            return MarkdownReader.upgradeV1(table);
+        }
+        return MarkdownReader.upgradeV2(table);
+    }
+    /**
+     * Version 1
+     * @param table the markdown object
+     * @returns the dbTable object
+     */
+    static upgradeV1(table) {
+        return {
+            name: table.name,
+            comment: table.comment,
+            primaryKey: table.primaryKey,
+            indexes: table.indexes || [],
+            foreignKeys: table.foreignKeys || [],
+            columns: table.columns || [],
+        };
+    }
+    /**
+     * Version 2
+     * @param table the markdown object
+     * @returns the dbTable object
+     */
+    static upgradeV2(table) {
+        const basic = table.table && table.table.length > 0 ? table.table[0] : undefined;
+        return {
+            ...basic,
+            primaryKey: table.primaryKey?.length > 0 ? table.primaryKey[0] : undefined,
+            indexes: table.indexes || [],
+            foreignKeys: table.foreignKeys || [],
+            columns: table.columns || [],
+        };
+    }
+}
+exports.MarkdownReader = MarkdownReader;
 //# sourceMappingURL=markdownReader.js.map