wt-huatu 1.3.4

package/huatu/HuatuSymbolArray.js

@@ -0,0 +1,235 @@
+import { HuatuDrawing } from "./HuatuDrawing.js";
+import Vector from "../geometry/Vector.js";
+import { AngDeg } from "../geometry/AngDeg.js";
+import { HuatuDrawingGroup } from "./HuatuDrawingGroup.js";
+export class HuatuSymbolArray extends HuatuDrawingGroup {
+    static METHODS = ["line", "2d", "polar"];
+    symbol;
+    arrayMethod = "line";
+    startPoint; // Start point will not be used by Polar arraying method
+    deltaX = 0;
+    deltaY = 0;
+    /**
+     * This count will be shared when Array specified as Polar or Line type
+     * If specified as 2D, then countX and countY will work.
+     */
+    count = 1;
+    countX = 1;
+    countY = 1;
+    center;
+    startDeg;
+    deltaDeg;
+    alignCenter;
+    transforms = [];
+    constructor(name, symbol, desc) {
+        super(name, desc);
+        // Symbol array will not accept any transforming
+        this.acceptTransform = false;
+        this.symbol = symbol;
+    }
+    /**
+     * Resolve the Linear generation of the Symbol Array
+     * @param count The Count to place the symbol
+     * @param dx Interval in X-axis
+     * @param dy Interval in Y-axis
+     * @param scale Scale factor of the Symbol, could be a number, or a func like Si = f(i) where i is the growing index
+     */
+    configLine(startPoint, count, dx, dy, scale, rotDeg) {
+        this.startPoint = startPoint;
+        // Clear element buffer at first
+        this.elements = [];
+        this.arrayMethod = "line";
+        count = Math.floor(count);
+        this.count = count >= 1 ? count : 1;
+        this.deltaX = dx ?? 0;
+        this.deltaY = dy ?? 0;
+        if (scale && typeof scale === "number") {
+            scale = scale > 0 ? scale : undefined; // non-positive scale will be discarded
+        }
+        for (let i = 0; i < this.count; i++) {
+            const transform = {
+                x: this.startPoint.x + i * this.deltaX,
+                y: this.startPoint.y + i * this.deltaY
+            };
+            if (scale) {
+                if (typeof scale === "function") {
+                    try {
+                        let newScale = scale(i);
+                        if (newScale && newScale > 0)
+                            transform.scale = newScale;
+                    }
+                    catch (error) {
+                        // Nothing to do
+                    }
+                }
+                else {
+                    transform.scale = scale;
+                }
+            }
+            if (rotDeg)
+                transform.rotDeg = rotDeg;
+            this.transforms.push(transform);
+            this.addElement(new HuatuDrawing(this.symbol, undefined, transform, this.alignCenter));
+        }
+    }
+    /**
+     * Resolve the 2D generation of the Symbol Array
+     * @param countX The count in X-axis
+     * @param countY The Count in Y-axis
+     * @param dx Interval in X-axis
+     * @param dy Interval in Y-axis
+     * @param scale Scale factor of the symbol, it could be a number or a func like Sxy = f(ix, iy), where ix and iy
+     *              is the growing index in X- and Y-axis
+     */
+    config2D(startPoint, countX, countY, dx, dy, scale, rotDeg) {
+        this.startPoint = startPoint;
+        // Clear element buffer at first
+        this.elements = [];
+        this.arrayMethod = "2d";
+        countX = Math.floor(countX);
+        countY = Math.floor(countY);
+        this.countX = countX >= 1 ? countX : 1;
+        this.countY = countY >= 1 ? countY : 1;
+        this.deltaX = dx ?? 0;
+        this.deltaY = dy ?? 0;
+        this.count = this.countX * this.countY;
+        if (scale && typeof scale === "number") {
+            scale = scale > 0 ? scale : undefined; // non-positive scale will be discarded
+        }
+        for (let iX = 0; iX < this.countX; iX++) {
+            for (let iY = 0; iY < this.countY; iY++) {
+                const transform = {
+                    x: this.startPoint.x + iX * this.deltaX,
+                    y: this.startPoint.y + iY * this.deltaY,
+                };
+                if (scale) {
+                    if (typeof scale === "function") {
+                        try {
+                            let newScale = scale(iX, iY);
+                            if (newScale && newScale > 0)
+                                transform.scale = newScale;
+                        }
+                        catch (error) {
+                            // Nothing to do
+                        }
+                    }
+                    else {
+                        transform.scale = scale;
+                    }
+                }
+                if (rotDeg)
+                    transform.rotDeg = rotDeg;
+                this.transforms.push(transform);
+                this.addElement(new HuatuDrawing(this.symbol, undefined, transform, this.alignCenter));
+            }
+        }
+    }
+    /**
+     * Resolve the polar method of arraying
+     * @param count How many symbols should be arrayed
+     * @param center The center to make the Array, i.e. the center of rotating
+     * @param radius How far should be the symbol located from the center, it could be a function of rotating of Angle,
+     *               e.g. R = f(theta), here, the unit of theta is Radian(not degree), to make it convenient to import
+     *               existing math curves which does this way
+     * @param scale How large will the symbol be scaled to, it could be a function of radius
+     * @param startDeg The start rotating angle, in degree
+     * @param deltaDeg The Interval of the rotating angle
+     * @param symbolNotRotate A switch to make sure if the symbol should stay not rotated
+     */
+    configPolar(count, center, radius, scale, // The Scale parameter, if could be the function of Radius
+    startDeg, deltaDeg, symbolNotRotate) {
+        // Clear element buffer at first
+        this.elements = [];
+        count = Math.floor(count);
+        this.count = count >= 1 ? count : 1;
+        this.center = center;
+        this.startDeg = startDeg ?? 0;
+        this.deltaDeg = deltaDeg ?? 30;
+        let constantRadius;
+        if (typeof radius === "number") {
+            constantRadius = Math.abs(radius);
+        }
+        if (scale && typeof scale === "number") {
+            scale = scale > 0 ? scale : undefined; // non-positive scale will be discarded
+        }
+        for (let i = 0; i < this.count; i++) {
+            const deg = this.startDeg + i * this.deltaDeg;
+            const ang = AngDeg.deg2Ang(deg); // Here is the conversion, please notice
+            // Default radius will be zero, i.e. if no radius specified, all the symbols will be placed at 'Center'
+            let r = 0;
+            if (constantRadius)
+                r = constantRadius;
+            else if (typeof radius === "function") {
+                try {
+                    r = radius(ang); // Use the angle in Radian
+                }
+                catch (error) {
+                    // Nothing to do
+                }
+            }
+            const loc = Vector.fromPoint(this.center).moveByLenAndAng(r, ang);
+            const transform = {
+                x: loc.x,
+                y: loc.y
+            };
+            if (!symbolNotRotate) {
+                transform.rotDeg = deg;
+            }
+            if (scale) {
+                if (typeof scale === "function") {
+                    try {
+                        let newScale = scale(r); // Scale is a func of Radius, please note
+                        if (newScale && newScale > 0)
+                            transform.scale = newScale;
+                    }
+                    catch (error) {
+                        // Nothing to do
+                    }
+                }
+                else {
+                    transform.scale = scale;
+                }
+            }
+            this.transforms.push(transform);
+            this.addElement(new HuatuDrawing(this.symbol, undefined, transform, this.alignCenter));
+        }
+    }
+    static optsSymbolArray = {
+        keys: [
+            ["symbol", "sym"],
+            ["startPoint", "start", "from"],
+            ["desc"],
+            ["method", "arrayMethod"],
+            ["deltaX", "dx"],
+            ["deltaY", "dy"],
+            ["count"],
+            ["countX"],
+            ["countY"],
+            ["center", "centerPoint", "at"],
+            ["rotDeg", "rot", "rotate"],
+            ["alignCenter"],
+            ["radius", "r"],
+            ["scale"],
+            ["notRotate", "noRotate", "noRot"],
+            ["startDeg", "initialDeg", "iniDeg"],
+            ["deltaDeg", "degDelta", "degD", "dDeg"],
+        ],
+        ints: [
+            "count",
+            "countX",
+            "countY",
+        ],
+        numbers: [],
+        booleans: [
+            "alignCenter",
+            "notRotate", "noRotate", "noRot"
+        ],
+        allowAppend: [],
+        qualifiers: {
+            "method": HuatuSymbolArray.METHODS,
+        },
+        blindGuess: {
+            "method": HuatuSymbolArray.METHODS,
+        }
+    };
+}

package/huatu/HuatuTransform.js

@@ -0,0 +1,113 @@
+import { SvgPoint } from "../svg/SvgPoint.js";
+import { WtMath } from "../math/WtMath.js";
+export class HuatuTransform {
+    x;
+    y;
+    rotCx;
+    rotCy;
+    rotDeg;
+    scale;
+    constructor(x, y, rotCx, rotCy, rotDeg, scale) {
+        this.x = x;
+        this.y = y;
+        this.rotCx = rotCx;
+        this.rotCy = rotCy;
+        this.rotDeg = rotDeg;
+        this.scale = scale;
+    }
+    static addMove(arr, move) {
+        if (!WtMath.isZero(move.x) || !WtMath.isZero(move.y)) {
+            arr.push(`translate(${SvgPoint.toCoors(move)})`);
+        }
+    }
+    static addRotate(arr, rotDeg, rotCenter) {
+        if (!WtMath.isZero(rotDeg)) {
+            const vals = [rotDeg];
+            if (rotCenter) {
+                vals.push(rotCenter.x, rotCenter.y);
+            }
+            const valStrs = vals.map(x => `${x}`).join(",");
+            arr.push(`rotate(${valStrs})`);
+        }
+    }
+    static addScale(arr, scale, scaleCenter) {
+        if (!WtMath.isEqual(scale, 1)) {
+            if (scaleCenter) {
+                const dx = scaleCenter.x * (1 - scale), dy = scaleCenter.y * (1 - scale);
+                arr.push(`translate(${dx},${dy})`);
+            }
+            arr.push(`scale(${scale})`);
+        }
+    }
+    static buildTransformAttrsForBlockAndPath(transform) {
+        if (!transform)
+            return [];
+        const move = (transform.x || transform.y)
+            ? new SvgPoint(transform.x ?? 0, transform.y ?? 0)
+            : undefined;
+        const attrs = [];
+        if (transform.rotDeg) {
+            const rotCenter = new SvgPoint(0, 0);
+            if (transform.rotCx)
+                rotCenter.x = transform.rotCx;
+            if (transform.rotCy)
+                rotCenter.y = transform.rotCy;
+            const scale = HuatuTransform.judgeScale(transform);
+            // Rotate at
+            HuatuTransform.addRotate(attrs, transform.rotDeg, rotCenter);
+            // Scale at
+            HuatuTransform.addScale(attrs, scale, rotCenter);
+        }
+        else {
+            if (transform.scale) {
+                const scale = HuatuTransform.judgeScale(transform);
+                let scaleCenter = (transform.rotCx || transform.rotCy)
+                    ? new SvgPoint(transform.rotCx ?? 0, transform.rotCy ?? 0)
+                    : undefined;
+                HuatuTransform.addScale(attrs, scale, scaleCenter);
+            }
+        }
+        // First move action will be placed as last
+        if (move) {
+            HuatuTransform.addMove(attrs, move);
+        }
+        return attrs;
+    }
+    static buildTransformStrForBlockAndPath(transform) {
+        if (!transform)
+            return "";
+        const attrs = HuatuTransform.buildTransformAttrsForBlockAndPath(transform);
+        if (attrs.length < 1)
+            return "";
+        return `transform="${attrs.join(" ")}"`;
+    }
+    static buildTransformAttrsForSymbol(transform) {
+        if (!transform)
+            return [];
+        const move = (transform.x || transform.y)
+            ? new SvgPoint(transform.x ?? 0, transform.y ?? 0)
+            : undefined;
+        const attrs = [];
+        if (transform.rotDeg) {
+            // If the rotation center is not given, then use the point of move
+            // If both not given, then leave no translate action
+            const rotCenter = transform.rotCx || transform.rotCy
+                ? new SvgPoint(transform.rotCx ?? 0, transform.rotCy ?? 0)
+                : move;
+            if (rotCenter)
+                HuatuTransform.addMove(attrs, rotCenter);
+            HuatuTransform.addRotate(attrs, transform.rotDeg);
+        }
+        else if (move) {
+            HuatuTransform.addMove(attrs, move);
+        }
+        return attrs;
+    }
+    static judgeScale(transform) {
+        if (!transform)
+            return 1;
+        if (!transform.scale || transform.scale <= 0)
+            return 1;
+        return transform.scale;
+    }
+}

package/huatu/HuatuVar.js

@@ -0,0 +1,17 @@
+export class HuatuVar {
+    name;
+    value;
+    howGet;
+    constructor(name, value, howGet) {
+        this.howGet = howGet ?? "direct";
+        this.name = name;
+        this.value = value;
+    }
+    /**
+     * Return the value of the variable, return 0 if not set.
+     * @returns the value of this variable
+     */
+    getValue() {
+        return this.value ?? 0;
+    }
+}

package/huatu/HuatuYml.js

@@ -0,0 +1,271 @@
+import { IndentParsingStack } from "./IndentParsingStack.js";
+export class HuatuYml {
+    static parseYml(yml) {
+        // Prepare error handling
+        let hasError = false;
+        // Prepare the result
+        const res = {
+            succeeded: false,
+            errorMessages: []
+        };
+        // The regex to match a "Real" comment, conditions are:
+        //  - The Comment part starts with a '#' sign
+        //  - The # sign is not followed by a ':', because this will escape the '#' char to be used in label text
+        //  - The # sign is not followed by 3/6/8 color (hex) codes(a-z, 0-9), because this will build some color
+        const YML_COMMENT_REGEX = /#(?!(:|([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})\b))(.*)$/ig;
+        const REGEX_MATCH_LIST = /^(\s*)-(\s.*|$)/i;
+        const REGEX_MATCH_KEY_VALUE = /^(\s*)(\$?[a-z][a-z0-9_]*)\s*:\s?(.*)$/i;
+        const parseKeyVal = (line) => {
+            const match = REGEX_MATCH_KEY_VALUE.exec(line);
+            if (match) {
+                return {
+                    indentLevel: Math.floor(match[1].length / 2),
+                    key: match[2],
+                    value: match[3].trim(),
+                };
+            }
+            else {
+                let indentLevel = Math.floor(/\s*/.exec(line)[0].length / 2);
+                return {
+                    indentLevel: indentLevel,
+                    key: undefined,
+                    value: line.trim(), // If line is not empty, then prepend a space
+                };
+            }
+        };
+        // Process the input
+        const ymlLines = yml.replace(/\r/ig, "").split('\n');
+        const lines = ymlLines
+            .map((l, i) => {
+            const lClean = l.replace(/#:/g, "_^;_;^_") // Backup the '#' char
+                .replace(YML_COMMENT_REGEX, "") // Remove comment
+                .replace(/_\^;_;\^_/g, "#") // Restore # char
+                .trimEnd() // Remove trailing spaces
+                .replace(/\t/g, "  "); // Replace tab key to two spaces
+            return lClean
+                ? {
+                    value: lClean,
+                    lineNumber: i + 1
+                }
+                : undefined;
+        })
+            .filter(l => !!l)
+            .map(l => {
+            let lineInfo;
+            const tryAsList = l.value.match(REGEX_MATCH_LIST);
+            if (tryAsList) {
+                const res = parseKeyVal(tryAsList[2].trim());
+                lineInfo = {
+                    lineNumber: l.lineNumber,
+                    indentLevel: Math.floor(tryAsList[1].length / 2),
+                    isListItem: true,
+                    key: res.key,
+                    value: res.value.trim(),
+                    isPureValue: false,
+                };
+            }
+            else {
+                const res = parseKeyVal(l.value);
+                lineInfo = {
+                    lineNumber: l.lineNumber,
+                    indentLevel: res.indentLevel,
+                    isListItem: false,
+                    key: res.key,
+                    value: res.value,
+                    isPureValue: !res.key
+                };
+            }
+            return lineInfo;
+        })
+            .filter(l => !!l);
+        // If has error, then skip the steps following
+        if (hasError)
+            return res;
+        if (lines.length < 1) {
+            hasError = true;
+            res.errorMessages.push({
+                lineNumber: 0,
+                message: 'No valid line ever input!'
+            });
+        }
+        else if (lines[0].isPureValue) {
+            hasError = true;
+            res.errorMessages.push({
+                lineNumber: lines[0].lineNumber,
+                message: "First line mustn't be pure value line!"
+            });
+        }
+        if (hasError)
+            return res;
+        // Append pure-value lines into previous
+        const realLines = [lines[0]]; // Initialize with the first line
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.isPureValue && !line.isListItem) {
+                if (line.value) {
+                    const lastLine = realLines[realLines.length - 1];
+                    if (line.indentLevel > lastLine.indentLevel) {
+                        lastLine.value = lastLine.value ? `${lastLine.value} ${line.value}` : line.value;
+                    }
+                    else {
+                        hasError = true;
+                        res.errorMessages.push({
+                            lineNumber: line.lineNumber,
+                            message: "Continuing text should have more indent than its parent."
+                        });
+                        return res;
+                    }
+                }
+            }
+            else {
+                realLines.push(line);
+            }
+        }
+        // Parse the YML lines into Object
+        const indentLevelMin = Math.min(...realLines.map(l => l.indentLevel));
+        const indentLevelMax = Math.max(...realLines.map(l => l.indentLevel));
+        const indentLevelCount = indentLevelMax - indentLevelMin + 1 + 1;
+        realLines.forEach(l => {
+            l.indentLevel -= indentLevelMin;
+        });
+        const stacks = [];
+        for (let i = 0; i < indentLevelCount; i++) {
+            stacks.push(new IndentParsingStack());
+        }
+        /**
+         * This function is used to make the object composed by following sub-stacks
+         * for the current stack that is going to close current open item.
+         */
+        const buildObjOnClose = (indentLevel) => {
+            let objOnClose = undefined;
+            for (let j = indentLevelCount - 1; j > indentLevel; j--) {
+                if (stacks[j].inUse) {
+                    stacks[j].close(objOnClose);
+                    objOnClose = stacks[j].buildObj();
+                    stacks[j].stop();
+                }
+            }
+            return objOnClose;
+        };
+        for (let i = 0; i < realLines.length; i++) {
+            const line = realLines[i];
+            const stack = stacks[line.indentLevel];
+            // Check if the line has invalid indent, i.e. over-indented, or less-indented
+            let indentError = "";
+            if (line.indentLevel > 0) {
+                for (let j = line.indentLevel - 1; j >= 0; j--) {
+                    if (stacks[j].inUse && !stacks[j].isOpen) {
+                        indentError = "Over Indented";
+                        break;
+                    }
+                }
+            }
+            if (!stack.inUse) {
+                for (let j = line.indentLevel + 1; j < indentLevelCount; j++) {
+                    if (stacks[j].inUse) {
+                        indentError = "Less Indented";
+                        break;
+                    }
+                }
+            }
+            if (indentError) {
+                hasError = true;
+                res.errorMessages.push({
+                    lineNumber: line.lineNumber,
+                    message: indentError,
+                });
+                return res;
+            }
+            if (stack.inUse) {
+                // Check if coming item has a different item type, list or not
+                if ((stack.isList && !line.isListItem) || (!stack.isList && line.isListItem)) {
+                    hasError = true;
+                    res.errorMessages.push({
+                        lineNumber: line.lineNumber,
+                        message: "You cannot mix list and/or dictionary definitions."
+                    });
+                    return res;
+                }
+                if (stack.isOpen) { // Let's close all the sub and sub level stacks
+                    stack.close(buildObjOnClose(line.indentLevel));
+                }
+                // Push current item into the stack
+                if (line.isListItem) {
+                    if (line.key) {
+                        stack.open(); // Make it open
+                        const stackNext = stacks[line.indentLevel + 1];
+                        stackNext.start(false, line.key, line.value); // Make next-level stack in use
+                    }
+                    else {
+                        if (line.value)
+                            stack.add("", line.value);
+                        else
+                            stack.open();
+                    }
+                }
+                else {
+                    if (line.key) {
+                        const addRes = stack.add(line.key, line.value);
+                        if (addRes) {
+                            hasError = true;
+                            res.errorMessages.push({
+                                lineNumber: line.lineNumber,
+                                message: addRes,
+                            });
+                            return res;
+                        }
+                    }
+                }
+            }
+            else { // Start the stack
+                if (line.isListItem) {
+                    if (line.key) {
+                        stack.start(true);
+                        const stackNext = stacks[line.indentLevel + 1];
+                        stackNext.start(false, line.key, line.value); // Leave the key and value to next-level stack
+                    }
+                    else {
+                        stack.start(true, undefined, line.value); // If no key, then add into list if value presented
+                    }
+                }
+                else {
+                    stack.start(false, line.key, line.value);
+                }
+            }
+        }
+        // Close the root stack
+        stacks[0].close(buildObjOnClose(0));
+        res.rootObj = stacks[0].buildObj();
+        res.succeeded = true;
+        return res;
+    }
+    /**
+     * A tool function to copy the source object to a new one. With the option of accepted key list and
+     * string replacing function.
+     * @param srcObj The Object to be processed
+     * @param acceptedRootKeys A list of which keys are accepted, if not presented, all keys will be accepted
+     * @param replaceFunc A function to replace string occurrences
+     * @returns The copied/processed object
+     */
+    static copyObj(srcObj, acceptedRootKeys, replaceFunc) {
+        const resObj = {};
+        for (let k in srcObj) {
+            if (acceptedRootKeys && !acceptedRootKeys.includes(k))
+                continue;
+            const v = srcObj[k];
+            if (typeof v === "string") {
+                resObj[k] = replaceFunc ? replaceFunc(v) : v;
+            }
+            else if (Array.isArray(v)) {
+                resObj[k] = [
+                    ...v.filter(x => typeof x === "string")
+                        .map(x => replaceFunc ? replaceFunc(x) : x)
+                ];
+            }
+            else if (typeof v === "object") {
+                resObj[k] = HuatuYml.copyObj(v, undefined, replaceFunc);
+            }
+        }
+        return resObj;
+    }
+}

package/huatu/IHuatu.js

@@ -0,0 +1,2 @@
+/** This file holds all the data structures designed for WT Huatu, all the modelling will be placed here. */
+export {};

package/huatu/IHuatuYml.js

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