git.kianting.info Git - clo/blob - src/libclo/index.js

   1 "use strict";
   2 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
   3     if (k2 === undefined) k2 = k;
   4     var desc = Object.getOwnPropertyDescriptor(m, k);
   5     if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
   6       desc = { enumerable: true, get: function() { return m[k]; } };
   7     }
   8     Object.defineProperty(o, k2, desc);
   9 }) : (function(o, m, k, k2) {
  10     if (k2 === undefined) k2 = k;
  11     o[k2] = m[k];
  12 }));
  13 var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
  14     Object.defineProperty(o, "default", { enumerable: true, value: v });
  15 }) : function(o, v) {
  16     o["default"] = v;
  17 });
  18 var __importStar = (this && this.__importStar) || function (mod) {
  19     if (mod && mod.__esModule) return mod;
  20     var result = {};
  21     if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
  22     __setModuleDefault(result, mod);
  23     return result;
  24 };
  25 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
  26     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
  27     return new (P || (P = Promise))(function (resolve, reject) {
  28         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
  29         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
  30         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
  31         step((generator = generator.apply(thisArg, _arguments || [])).next());
  32     });
  33 };
  34 Object.defineProperty(exports, "__esModule", { value: true });
  35 exports.Clo = exports.calculateTextWidthHeightAux = exports.calculateTextWidthHeight = exports.hyphenTkTree = exports.filterEmptyString = exports.spacesToBreakpoint = exports.hyphenForClo = exports.splitCJKV = exports.twoReturnsToNewline = exports.ptToPx = exports.cjkvRegexPattern = exports.cjkvBlocksInRegex = exports.defaultFrameStyle = exports.defaultTextStyle = exports.A4_IN_PX = exports.Direction = void 0;
  36 const canva_1 = require("../canva");
  37 const fontkit = __importStar(require("fontkit"));
  38 const breakLines = __importStar(require("./breakLines"));
  39 require("pdfkit");
  40 const pdf_lib_1 = require("pdf-lib");
  41 const fs = __importStar(require("fs"));
  42 /**
  43  * TYPES
  44  */
  45 /**
  46  * text direction
  47  * LTR - left to right
  48  * TTB - top to bottom
  49  * etc.
  50  */
  51 var Direction;
  52 (function (Direction) {
  53     Direction[Direction["LTR"] = 0] = "LTR";
  54     Direction[Direction["RTL"] = 1] = "RTL";
  55     Direction[Direction["TTB"] = 2] = "TTB";
  56     Direction[Direction["BTT"] = 3] = "BTT";
  57 })(Direction || (exports.Direction = Direction = {}));
  58 /**
  59  * DEFAULT CONST PART
  60  */
  61 exports.A4_IN_PX = { "width": 793.7,
  62     "height": 1122.5 };
  63 exports.defaultTextStyle = {
  64     family: "FreeSerif",
  65     size: ptToPx(12),
  66     textWeight: canva_1.TextWeight.REGULAR,
  67     fontStyle: canva_1.FontStyle.ITALIC,
  68 };
  69 exports.defaultFrameStyle = {
  70     directionInsideLine: Direction.LTR,
  71     direction: Direction.TTB,
  72     baseLineskip: ptToPx(15),
  73     textStyle: exports.defaultTextStyle,
  74     x: exports.A4_IN_PX.width * 0.10,
  75     y: exports.A4_IN_PX.height * 0.10,
  76     width: exports.A4_IN_PX.width * 0.80,
  77     height: exports.A4_IN_PX.height * 0.80,
  78     content: null,
  79 };
  80 /**
  81  * definition for cjk scripts
  82  *  - Hani : Han Character
  83  *  - Hang : Hangul
  84  *  - Bopo : Bopomofo
  85  *  - Kana : Katakana
  86  *  - Hira : Hiragana
  87 */
  88 exports.cjkvBlocksInRegex = ["Hani", "Hang", "Bopo", "Kana", "Hira"];
  89 exports.cjkvRegexPattern = new RegExp("((?:" +
  90     exports.cjkvBlocksInRegex.map((x) => "\\p{Script_Extensions=" + x + "}").join("|") + ")+)", "gu");
  91 /**
  92  * FUNCTION PART
  93  */
  94 /**
  95  * convert from ptToPx
  96  * @param pt pt size value
  97  * @returns the corresponding px value
  98  */
  99 function ptToPx(pt) {
 100     return pt * 4.0 / 3.0;
 101 }
 102 exports.ptToPx = ptToPx;
 103 /**
 104  *  REGISTER PART
 105  */
 106 /**
 107  * convert '\n\n' to newline command ["nl"]
 108  * @param arr the input `tkTree`
 109  * @param clo the `Clo` object
 110  * @returns the input tktree
 111  */
 112 function twoReturnsToNewline(arr, clo) {
 113     var middle = [];
 114     for (let i = 0; i < arr.length; i++) {
 115         var item = arr[i];
 116         if (!Array.isArray(item)) {
 117             middle = middle.concat(item.split(/(\n\n)/g));
 118         }
 119         else {
 120             middle.push(item);
 121         }
 122     }
 123     var result = [];
 124     for (let j = 0; j < middle.length; j++) {
 125         var item = middle[j];
 126         if (!Array.isArray(item) && item == "\n\n") {
 127             result.push(["nl"]); // push a newline command to the result `tkTree`
 128         }
 129         else {
 130             result.push(middle[j]);
 131         }
 132     }
 133     return result;
 134 }
 135 exports.twoReturnsToNewline = twoReturnsToNewline;
 136 /**
 137  * split CJKV and non-CJKV
 138  *
 139  * @param arr : input tkTree
 140  * @returns a splitted tkTree (by CJK and NonCJK)
 141  * - Examples:
 142  *  ```
 143  *  [`many臺中daylight`] => [`many`, `臺中`, `dahylight`]
 144  *  ```
 145  */
 146 function splitCJKV(arr, clo) {
 147     var result = [];
 148     for (let i = 0; i < arr.length; i++) {
 149         var item = arr[i];
 150         if (!Array.isArray(item)) {
 151             result = result.concat(item.split(exports.cjkvRegexPattern));
 152         }
 153         else {
 154             result.push(item);
 155         }
 156     }
 157     return result;
 158 }
 159 exports.splitCJKV = splitCJKV;
 160 /**
 161  * hyphenation for a clo document
 162  * @param arr the array for a `tkTree`
 163  * @param clo the Clo object
 164  */
 165 function hyphenForClo(arr, clo) {
 166     let hyphenLanguage = clo.attrs["hyphenLanguage"];
 167     let res = hyphenTkTree(arr, hyphenLanguage);
 168     return res;
 169 }
 170 exports.hyphenForClo = hyphenForClo;
 171 /**
 172  * convert spaces to Breakpoint
 173  * \s+ => ["bp" [\s+] ""]
 174  * @param arr the tkTree input text stream
 175  * @param clo the Clo object
 176  * @returns the converted object
 177  */
 178 function spacesToBreakpoint(arr, clo) {
 179     let spacePattern = /^([ \t]+)$/g;
 180     var result = [];
 181     for (let i = 0; i < arr.length; i++) {
 182         var item = arr[i];
 183         if (!Array.isArray(item) && item.match(spacePattern)) {
 184             // push a breakpoint command to the result `tkTree`
 185             result.push(['bp', [["hglue", "0.1"], item], ""]);
 186         }
 187         else {
 188             result.push(item);
 189         }
 190     }
 191     return result;
 192 }
 193 exports.spacesToBreakpoint = spacesToBreakpoint;
 194 /**
 195  * remove all the `` (empty string) in the arr
 196  * @param arr the tkTree to be filtered
 197  * @param clo the Clo file
 198  */
 199 function filterEmptyString(arr, clo) {
 200     if (Array.isArray(arr)) {
 201         arr.filter((x) => { return x != ``; });
 202     }
 203     return arr;
 204 }
 205 exports.filterEmptyString = filterEmptyString;
 206 /**
 207  * OTHER FUNCTIONS
 208  */
 209 /**
 210  * hyphenate for a tkTree
 211  *  - hyphenation => ["bp", "", "-"]
 212  * @param arr the tkTree array
 213  * @param lang ISO 639 code for the language
 214  */
 215 function hyphenTkTree(arr, lang) {
 216     // import corresponding hyphen language data and function
 217     let hyphen = require("hyphen/" + lang);
 218     let result = [];
 219     for (let i = 0; i < arr.length; i++) {
 220         let element = arr[i];
 221         let splitter = "分"; // a CJKV
 222         if (!Array.isArray(element)) {
 223             let hyphenatedElement = hyphen.hyphenateSync(element, { hyphenChar: splitter });
 224             let hyphenatedSplitted = hyphenatedElement.split(splitter);
 225             var newSplitted = [];
 226             for (var j = 0; j < hyphenatedSplitted.length - 1; j++) {
 227                 newSplitted.push(hyphenatedSplitted[j]);
 228                 // "bp" for breakpoint
 229                 newSplitted.push(["bp", "", "-"]); //insert a breakable point (bp) mark
 230             }
 231             newSplitted.push(hyphenatedSplitted[hyphenatedSplitted.length - 1]);
 232             result = result.concat(newSplitted);
 233         }
 234         else {
 235             result.push(element);
 236         }
 237     }
 238     return result;
 239 }
 240 exports.hyphenTkTree = hyphenTkTree;
 241 /**
 242  * calculate the text width and Height with a given `TextStyle`
 243  * @param preprocessed
 244  * @param defaultFontStyle
 245  */
 246 function calculateTextWidthHeight(element, style) {
 247     return __awaiter(this, void 0, void 0, function* () {
 248         var res = [];
 249         for (var i = 0; i < element.length; i++) {
 250             res.push(yield calculateTextWidthHeightAux(element[i], style));
 251         }
 252         res = res.flat();
 253         return res;
 254     });
 255 }
 256 exports.calculateTextWidthHeight = calculateTextWidthHeight;
 257 /**
 258  * calculate the text width and Height with a given `TextStyle`
 259  * @param preprocessed
 260  * @param defaultFontStyle
 261  */
 262 function calculateTextWidthHeightAux(element, style) {
 263     return __awaiter(this, void 0, void 0, function* () {
 264         var result = [];
 265         let fontPair = (0, canva_1.fontStyleTofont)(style);
 266         if (fontPair.path.match(/\.ttc$/)) {
 267             var font = yield fontkit.openSync(fontPair.path, fontPair.psName);
 268         }
 269         else {
 270             var font = yield fontkit.openSync(fontPair.path);
 271         }
 272         if (!Array.isArray(element)) {
 273             var run = font.layout(element, undefined, undefined, undefined, "ltr");
 274             for (var j = 0; j < run.glyphs.length; j++) {
 275                 let runGlyphsItem = run.glyphs[j];
 276                 let item = {
 277                     x: null,
 278                     y: null,
 279                     textStyle: style,
 280                     direction: Direction.LTR,
 281                     width: (runGlyphsItem.advanceWidth) * (style.size) / 1000,
 282                     height: (runGlyphsItem.bbox.maxY - runGlyphsItem.bbox.minY) * (style.size) / 1000,
 283                     content: element[j],
 284                     minX: runGlyphsItem.bbox.minX,
 285                     maxX: runGlyphsItem.bbox.maxX,
 286                     minY: runGlyphsItem.bbox.minY,
 287                     maxY: runGlyphsItem.bbox.maxY
 288                 };
 289                 result.push(item);
 290             }
 291             return result;
 292         }
 293         else if (element[0] == "bp") {
 294             var beforeNewLine = yield calculateTextWidthHeightAux(element[1], style);
 295             if (Array.isArray(beforeNewLine)) {
 296                 beforeNewLine = beforeNewLine.flat();
 297             }
 298             let afterNewLine = yield calculateTextWidthHeightAux(element[2], style);
 299             if (Array.isArray(afterNewLine)) {
 300                 afterNewLine = afterNewLine.flat();
 301             }
 302             let breakPointNode = {
 303                 original: beforeNewLine,
 304                 newLined: afterNewLine,
 305             };
 306             return breakPointNode;
 307         }
 308         else if (element[0] == "hglue" && !Array.isArray(element[1])) {
 309             let hGlue = { stretchFactor: parseFloat(element[1]) };
 310             return hGlue;
 311         }
 312         else {
 313             return calculateTextWidthHeight(element, style);
 314         }
 315     });
 316 }
 317 exports.calculateTextWidthHeightAux = calculateTextWidthHeightAux;
 318 /**
 319  * whole document-representing class
 320  */
 321 class Clo {
 322     constructor() {
 323         this.preprocessors = [];
 324         this.mainStream = [];
 325         this.attrs = {
 326             "page": exports.A4_IN_PX,
 327             "defaultFrameStyle": exports.defaultFrameStyle,
 328             "hyphenLanguage": 'en' // hyphenated in the language (in ISO 639)
 329         };
 330         // register the precessor functions
 331         this.preprocessorRegister(splitCJKV);
 332         this.preprocessorRegister(hyphenForClo);
 333         this.preprocessorRegister(twoReturnsToNewline);
 334         this.preprocessorRegister(spacesToBreakpoint);
 335         this.preprocessorRegister(filterEmptyString);
 336     }
 337     setAttr(attr, val) {
 338         Object.assign(this.attrs, attr, val);
 339     }
 340     getAttr(attr) {
 341         if (Object.keys(this.attrs).length === 0) {
 342             return this.attrs[attr];
 343         }
 344         else {
 345             return undefined;
 346         }
 347     }
 348     /**
 349      * register a function of preprocessor
 350      * @param f a function
 351      */
 352     preprocessorRegister(f) {
 353         this.preprocessors.push(f);
 354     }
 355     generatePdf() {
 356         return __awaiter(this, void 0, void 0, function* () {
 357             // preprocessed
 358             var preprocessed = this.mainStream;
 359             for (var i = 0; i < this.preprocessors.length; i++) {
 360                 preprocessed = this.preprocessors[i](preprocessed, this);
 361             }
 362             // generate the width and height of the stream
 363             let defaultFontStyle = this.attrs["defaultFrameStyle"].textStyle;
 364             let a = yield calculateTextWidthHeight(preprocessed, defaultFontStyle);
 365             let breakLineAlgorithms = new breakLines.BreakLineAlgorithm();
 366             // TODO
 367             //console.log(breakLineAlgorithms.totalCost(a,70));
 368             let segmentedNodes = breakLineAlgorithms.segmentedNodes(a, 70);
 369             console.log(this.segmentedNodesToFrameBox(segmentedNodes, this.attrs["defaultFrameStyle"]));
 370             // generate pdf
 371             const pdfDoc = yield pdf_lib_1.PDFDocument.create();
 372             var page = pdfDoc.addPage();
 373             page.drawText('You can create PDFs!');
 374             for (var j = 0; j < 1000; j += 5) {
 375                 if (j % 50 == 0) {
 376                     page.drawText(j.toString(), { x: 50, y: j });
 377                 }
 378                 page.drawLine({
 379                     start: { x: 0, y: j },
 380                     end: { x: 1000, y: j },
 381                     thickness: 0.5,
 382                     color: (0, pdf_lib_1.rgb)(0.75, 0.2, 0.2),
 383                     opacity: 0.20,
 384                 });
 385             }
 386             for (var i = 0; i < 1000; i += 5) {
 387                 if (i % 50 == 0) {
 388                     page.drawText(i.toString(), { x: i, y: 50 });
 389                 }
 390                 page.drawLine({
 391                     start: { x: i, y: 0 },
 392                     end: { x: i, y: 1000 },
 393                     thickness: 0.5,
 394                     color: (0, pdf_lib_1.rgb)(0.75, 0.2, 0.2),
 395                     opacity: 0.20,
 396                 });
 397             }
 398             pdfDoc.save();
 399             const pdfBytes = yield pdfDoc.save();
 400             fs.writeFileSync("blank.pdf", pdfBytes);
 401         });
 402     }
 403     segmentedNodesToFrameBox(segmentedNodes, frame) {
 404         let baseLineskip = frame.baseLineskip;
 405         let boxArrayEmpty = [];
 406         let bigBox = {
 407             x: frame.x,
 408             y: frame.y,
 409             textStyle: frame.textStyle,
 410             direction: frame.direction,
 411             width: frame.width,
 412             height: frame.height,
 413             content: boxArrayEmpty,
 414         };
 415         var bigBoxContent = boxArrayEmpty;
 416         let segmentedNodesFixed = segmentedNodes.map((x) => this.removeBreakPoints(x).flat());
 417         let segmentedNodeUnglue = segmentedNodesFixed.map((x) => this.removeGlue(x, frame).flat());
 418         for (var i = 0; i < segmentedNodesFixed.length - 1; i++) {
 419             var currentLineSkip = baseLineskip;
 420             var glyphMaxHeight = this.getGlyphMaxHeight(segmentedNodesFixed[i]);
 421             if (currentLineSkip === null || glyphMaxHeight > currentLineSkip) {
 422                 currentLineSkip = glyphMaxHeight;
 423             }
 424             var currentLineBox = {
 425                 x: null,
 426                 y: null,
 427                 textStyle: exports.defaultTextStyle,
 428                 direction: frame.directionInsideLine,
 429                 width: frame.width,
 430                 height: currentLineSkip,
 431                 content: segmentedNodeUnglue[i],
 432             };
 433             bigBoxContent.push(currentLineBox);
 434         }
 435         bigBox.content = bigBoxContent;
 436         return bigBox;
 437     }
 438     /**
 439      * get the max height of the glyph`[a, b, c]`
 440      * @param nodeLine the node line [a, b, c, ...]
 441      * @returns
 442      */
 443     getGlyphMaxHeight(nodeLine) {
 444         let segmentedNodeLineHeight = nodeLine.map((x) => { if ("height" in x && x.height > 0.0) {
 445             return x.height;
 446         }
 447         else {
 448             return 0.0;
 449         } });
 450         let maxHeight = Math.max(...segmentedNodeLineHeight);
 451         return maxHeight;
 452     }
 453     removeGlue(nodeLine, frame) {
 454         let breakLineAlgorithms = new breakLines.BreakLineAlgorithm();
 455         let glueRemoved = nodeLine.filter((x) => !breakLineAlgorithms.isHGlue(x));
 456         let onlyGlue = nodeLine.filter((x) => breakLineAlgorithms.isHGlue(x));
 457         let sumStretchFactor = onlyGlue.map((x) => { if ("stretchFactor" in x) {
 458             return x.stretchFactor;
 459         }
 460         else {
 461             return 0;
 462         } })
 463             .reduce((acc, cur) => acc + cur, 0);
 464         let glueRemovedWidth = glueRemoved.map((x) => { if ("width" in x) {
 465             return x.width;
 466         }
 467         else {
 468             return 0;
 469         } })
 470             .reduce((acc, cur) => acc + cur, 0);
 471         let offset = frame.width - glueRemovedWidth;
 472         var res = [];
 473         for (var i = 0; i < nodeLine.length; i++) {
 474             var ele = nodeLine[i];
 475             if (breakLineAlgorithms.isHGlue(ele)) {
 476                 let tmp = {
 477                     x: null,
 478                     y: null,
 479                     textStyle: null,
 480                     direction: frame.directionInsideLine,
 481                     width: ele.stretchFactor / sumStretchFactor * offset,
 482                     height: 0,
 483                     content: "",
 484                 };
 485                 res.push(tmp);
 486             }
 487             else {
 488                 res.push(ele);
 489             }
 490         }
 491         return res;
 492     }
 493     /**
 494      * remove breakpoints
 495      * @param boxitemline boxitem in a line with a breakpoint
 496      * @returns boxitemline with break points removed
 497      */
 498     removeBreakPoints(boxitemline) {
 499         var res = [];
 500         let breakLineAlgorithms = new breakLines.BreakLineAlgorithm();
 501         for (var i = 0; i < boxitemline.length; i++) {
 502             let ele = boxitemline[i];
 503             if (breakLineAlgorithms.isBreakPoint(ele)) {
 504                 if (i == boxitemline.length - 1) {
 505                     res.push(ele.newLined);
 506                 }
 507                 else {
 508                     res.push(ele.original);
 509                 }
 510             }
 511             else {
 512                 res.push(ele);
 513             }
 514         }
 515         return res;
 516     }
 517 }
 518 exports.Clo = Clo;
 519 /*
 520 export let a = new Clo();
 521 export default a; */